project.py

# -*- coding: utf-8 -*-
"""Contain the logic for conda environment creation from ``meta.yaml``.

cenv is a tool to handle conda environment creation and update from the
dependency-definition inside the ``meta.yaml`` file.

As default conda has two files for dependency management:
* the ``environment.yml``
* and the ``meta.yaml``

In the ``environment.yml`` the environment-definition is stored.
In the ``meta.yaml`` the required information to build a conda-package are
stored.
This means redundant information.

cenv collects the dependency-information and all project-specific settings
from the ``meta.yaml``.

The collected information is used to create / update the projects conda
environment.
"""
from argparse import ArgumentParser
from argparse import Namespace
from argparse import RawTextHelpFormatter
from pathlib import Path
from typing import List
from typing import NoReturn

import attr

from cenv_tool import __version__
from cenv_tool.rules import ARGPARSE_DESCRIPTION
from cenv_tool.rules import CondaCmdFormats
from cenv_tool.rules import RULES
from cenv_tool.rules import Rules
from cenv_tool.utils import CenvProcessError
from cenv_tool.utils import extract_dependencies_from_meta_yaml
from cenv_tool.utils import message
from cenv_tool.utils import read_config
from cenv_tool.utils import read_meta_yaml
from cenv_tool.utils import run_in_bash


@attr.s(slots=True, auto_attribs=True)
class Project:
    """Contain a python-project using conda environments.

    Containing methods to display information to current project and methods
    to update the projects conda-environment from the settings defined in the
    projects ``meta.yaml``.
    """

    rules: Rules
    conda_folder: Path = attr.ib(default=None)
    env_folder: Path = attr.ib(default=None)
    env_name: str = attr.ib(default=None)
    dependencies: dict = attr.ib(default=None)
    is_env: bool = attr.ib(default=None)
    export_environment_yml: bool = attr.ib(None)
    cmds: CondaCmdFormats = attr.ib(default=None)
    cmd_kwargs: dict = attr.ib(default=None)
    is_git: bool = attr.ib(default=None)

    def __attrs_post_init__(self):
        """Set the more complex attributes of the project class."""
        try:
            meta_yaml = read_meta_yaml(Path.cwd())
        except FileNotFoundError:
            message(text='project has no meta.yaml!', color='red')
            exit(1)
        settings = meta_yaml['extra']['cenv']
        dependencies = extract_dependencies_from_meta_yaml(meta_yaml)

        config = read_config()
        self.is_git = (Path.cwd() / self.rules.git_folder).exists()
        self.export_environment_yml = config['export_environment_yml']
        self.conda_folder = Path(config['conda_folder'])
        self.env_folder = Path(config['env_folder'])
        self.env_name = settings['env_name']
        self.dependencies = dependencies
        self.is_env = self.env_name in self.collect_available_envs()
        conda_bin = self.rules.conda_cmds.conda_bin(self.conda_folder)
        self.cmds = self.rules.conda_cmds
        self.cmd_kwargs = {
            'conda': conda_bin,
            'name': self.env_name,
            'pkgs': ' '.join([f'"{_}"' for _ in self.dependencies]),
        }

    def collect_available_envs(self) -> List[str]:
        """Collect the names of the conda environments currently installed.

        Parameters:
            conda_folder: the path where conda is installed.

        Returns:
            list of currently installed conda-environments

        """
        return run_in_bash(
            str(self.conda_folder.absolute()) +
            '/bin/conda env list | awk \'{ if( !($1=="#") ) print $1 }\'',
        ).split('\n')

    def write_new_md5sum(self):
        """Write new md5sum of ``meta.yaml`` to ``conda-build/meta.md5``."""
        message(text='write md5sum of meta.yaml', color='bold', special='row')
        command = (
            'echo "$(md5sum $PWD/conda-build/meta.yaml)" | '
            'cut -d\' \' -f1 > $PWD/conda-build/meta.md5'
        )
        run_in_bash(cmd=command)
        message(text='updated', color='green', special='end', indent=2)

    def export_environment_definition(self) -> NoReturn:
        """Export projects environment definition to an ``environment.yml``."""
        message(text='Export environment.yml ...', color='bold', special='row')
        run_in_bash(cmd=self.cmds.export.format(**self.cmd_kwargs))
        message(text='Exported', color='green', special='end', indent=2)

    def _remove_backup_environment(self) -> NoReturn:
        """Remove backup environment cloned from original environment."""
        run_in_bash(cmd=self.cmds.clean.format(**self.cmd_kwargs))

    def _restore_environment_from_backup(self, cloned: bool) -> NoReturn:
        """Restore the environment from the cloned backup environment.

        After restore the backup environment is removed.

        Parameters:
            cloned: indicates if the environment already existed and a backup
                was created.

        """
        message(text='Error during creation!', color='red', special='row')
        if self.is_env and cloned:
            message(text='Recreating backup', color='bold', special='row')
            run_in_bash(cmd=self.cmds.restore.format(**self.cmd_kwargs))
            self._remove_backup_environment()
            message(text='Recreated', color='green', special='end', indent=2)
        message(text='Exit', color='red', special='end')

    def _remove_previous_environment(self) -> NoReturn:
        """Remove old version of project environment.

        If the old environment can't be removed, the backup made is removed.
        """
        try:
            message(text='Remove existing env', color='bold', special='row')
            run_in_bash(cmd=self.cmds.remove.format(**self.cmd_kwargs))
            message(text='Removed', color='green', special='end', indent=2)
        except CenvProcessError:
            self._remove_backup_environment()
            message(
                text=(
                    'Could not remove environment because it is '
                    'activated! Please deactivate it first.'
                ),
                color='red',
            )
            exit(1)

    def clone_environment_as_backup(self) -> NoReturn:
        """Clone the existing environment as a backup.

        If the backup already exists, the previous backup is removed, then
        the new one is created by cloning the current project environment.
        """
        backup_name = f'{self.env_name}_backup'
        if backup_name in self.collect_available_envs():
            message(text='Clear old backup', color='bold', special='row')
            self._remove_backup_environment()
            message(text='Cleared', color='green', special='end', indent=2)
        message(text='Create backup', color='bold', special='row')
        run_in_bash(cmd=self.cmds.clone.format(**self.cmd_kwargs))
        message(text='Created', color='green', special='end', indent=2)

    def _handle_existing_environment(self) -> bool:
        """Check if environment already exists and create a backup of it."""
        if self.is_env:
            self.clone_environment_as_backup()
            self._remove_previous_environment()
            return True

        return False

    def create_environment(self, cloned: bool) -> NoReturn:
        """Create the environment for the project.

        Try to create the environment for the project. If the environment
        already existed and a backup was made and any error occure, restore the
        backup environment.
        If everything worked correctly finally remove the backup (if one was
        made).

        Parameters:
            cloned: indicates if the environment already existed and a backup
                was created.

        """
        message(text='Create environment', color='bold', special='row')

        try:
            run_in_bash(cmd=self.cmds.create.format(**self.cmd_kwargs))
        except CenvProcessError:
            self._restore_environment_from_backup(cloned=cloned)
            exit(1)

        if cloned:
            message(text='Clear backup', color='bold', special='row', indent=2)
            run_in_bash(cmd=self.cmds.clean.format(**self.cmd_kwargs))
            message(text='Cleared', color='green', special='end', indent=3)

        message(text='Created', color='green', special='end', indent=2)

    def update(self) -> NoReturn:
        """Create / recreate the conda environment of the current project.

        If the conda environment already exists, clone the environment as a
        backup and then remove original environment. Then create the new
        conda environment. If a backup was created it is
        removed afterwards. If any errors occurs during creation of the new
        environment, recreate the old environment from backup and remove the
        backup afterwards. If activated in the config-file, export the
        environment-definition of the created environment to an
        ``environment.yml`` file. Finally store the md5sum of the meta.yaml for
        the autoupdate feature.
        """
        if self.is_env:
            message(text=f'Updating {self.env_name}', color='cyan')
        else:
            message(text=f'Creating {self.env_name}', color='cyan')

        cloned = self._handle_existing_environment()

        self.create_environment(cloned=cloned)

        if self.export_environment_yml:
            self.export_environment_definition()

        self.write_new_md5sum()

        message(text='Done', color='green', special='end')


def _build_arguments() -> ArgumentParser:
    """Create arguments for the cenv-tool.

    Returns:
        the parsed arguments.

    """
    parser = ArgumentParser(
        description=ARGPARSE_DESCRIPTION,
        epilog='For additional information see http://www.cenv.ouroboros.info',
        formatter_class=RawTextHelpFormatter,
    )
    parser.add_argument(
        '-v',
        '--version',
        action='store_true',
        default=False,
        help='Show current version of cenv and exit.',
    )
    return parser


def main() -> NoReturn:
    """Collect the required args, initialize and run the Project."""
    parser = _build_arguments()
    options = parser.parse_args()
    if options.version:
        print(__version__)
    else:
        Project(rules=RULES).update()


if __name__ == '__main__':
    main()