diff --git a/docs/Installation.rst b/docs/Installation.rst index ee012cd9..a2ed485d 100644 --- a/docs/Installation.rst +++ b/docs/Installation.rst @@ -5,12 +5,12 @@ Installing EasyBuild EasyBuild is Python software, so there are a couple of ways to install it. -We recommend using the **bootstrap** install procedure described at :ref:`bootstrapping`, because of various issues -with the different installation tools that are available for Python packages. +We recommend installing EasyBuild using ``pip``. This method is described at :ref:`pip`. -Do take into account the required and optional dependencies (see :ref:`requirements` and :ref:`dependencies`). +It is also possible to install EasyBuild as a module. To do this, +use the 3-step procedure outlined at :ref:`eb_as_module`. -For advanced options, see :ref:`bootstrap_advanced_options`. +Do take into account the required and optional dependencies (see :ref:`requirements` and :ref:`dependencies`). Notes on other ways of installing EasyBuild are available under section :ref:`alt_inst_methods`. @@ -31,7 +31,8 @@ The only strict requirements are: * **Python**: - * Python 2.7, or Python 3.x (>= 3.5) + * Python 2.7, or Python 3.x (>= 3.5). Since Python 2 is end-of-life (https://www.python.org/doc/sunset-python-2/) we recommend + using Python 3 if it is available * **note**: only EasyBuild v4.0 (or newer) is compatible with Python 3, earlier EasyBuild releases require Python 2 @@ -49,325 +50,287 @@ The only strict requirements are: For more information on (optional) dependencies, see :ref:`dependencies`. -.. _bootstrapping: +.. _pip: -Bootstrapping EasyBuild +Using pip to Install EasyBuild ----------------------- -Installing any Python package can be a real pain, and since EasyBuild is basically -a set of Python packages glued together, installing EasyBuild may (ironically) cause some headaches. +Since EasyBuild is released as a Python package on PyPI (https://pypi.org/project/easybuild) +you can install it using ``pip``, the most commonly used tool for installing Python packages. -To resolve this, we have created a bootstrap script that installs the -latest EasyBuild version for you together with an environment module for -it - and yes, we use EasyBuild for doing so. +Install EasyBuild with:: -A demo of bootstrapping EasyBuild is available :ref:`here `. + pip install easybuild +You may need to tweak this command a bit, depending on your setup, see :ref:`more_pip`. -Bootstrapping procedure -~~~~~~~~~~~~~~~~~~~~~~~ +.. note:: + There are various other ways of installing Python packages, which we won't cover here. + If you are familiar with other tools like ``virtualenv`` or ``pipenv``, feel free to use those + instead to install EasyBuild. -The easiest way (by far) to install EasyBuild is by bootstrapping it, -i.e., installing the latest EasyBuild release (obtained from PyPI) using EasyBuild itself. +Sanity check +~~~~~~~~~~~~ -To bootstrap EasyBuild: +Compare the version of ``eb``, the main EasyBuild command, with the version of the EasyBuild module that was installed. +For example:: -* download the bootstrap script from https://raw.githubusercontent.com/easybuilders/easybuild-framework/develop/easybuild/scripts/bootstrap_eb.py -* execute it, and specify an installation prefix as an argument + $ module load EasyBuild + $ module list -Yes, it's that easy! + Currently Loaded Modules: + 1) EasyBuild/4.4.0 -The bootstrap script will perform a 3-stage bootstrap procedure: + $ eb --version + This is EasyBuild 4.4.0 (framework: 4.4.0, easyblocks: 4.4.0) on host example.local -* *stage 0:* download and install a specific version of the ``distribute`` Python package, which provides - the ``easy_install`` tool for installing Python software into a temporary directory -* *stage 1:* download and install the most recent version of EasyBuild from PyPI into a temporary location, using the - ``easy_install`` tool from stage 0 -* *stage 2:* install the most recent version of EasyBuild into the specified installation prefix, - using the temporary EasyBuild installation from stage 1 (inception!) +.. tip:: -This should result in an ``EasyBuild`` module that you can load to start using EasyBuild, after making sure the -module is available by updating ``$MODULEPATH``. More specifically, you need to include the ``modules/all`` -subdirectory of the specified installation prefix into ``$MODULEPATH``. + The Tcl-based or Lmod implementations of environment modules do their default sorting differently. + The former will normally sort in the lexicographic order, while Lmod follows + an approach that is closer to Python's construct ``LooseVersion`` way of ordering. Such aspects + may make a big difference, if you have installed both versions 1.9.0 and 1.15.2, + with respect to what is the version being loaded by default. -For example:: +You can also run ``eb --show-system-info`` to see system information relevant to EasyBuild, +or run``eb --show-config`` to see the default EasyBuild configuration (see also :ref:`configuring_easybuild`). - # pick an installation prefix to install EasyBuild to (change this to your liking) - EASYBUILD_PREFIX=$HOME/.local/easybuild +.. _updating: - # download script - curl -O https://raw.githubusercontent.com/easybuilders/easybuild-framework/develop/easybuild/scripts/bootstrap_eb.py +Updating an existing EasyBuild installation +~~~~~~~~~~~~ - # bootstrap EasyBuild - python bootstrap_eb.py $EASYBUILD_PREFIX +To upgrade to a newer EasyBuild version than the one currently installed: - # update $MODULEPATH, and load the EasyBuild module - module use $EASYBUILD_PREFIX/modules/all - module load EasyBuild +* ``pip install --upgrade easybuild`` will upgrade EasyBuild to the latest release. -.. note:: +.. _more_pip: - The path you specify to the bootstrap script is where EasyBuild should be installed. - If you also want software that is built/installed using EasyBuild to be located there, you will need - to configure EasyBuild accordingly (see :ref:`configuring_easybuild`), for example by - putting the definition for ``$EASYBUILD_PREFIX`` in your ``.bashrc``. +Additional pip install options +~~~~~~~~~~~~ - See also :ref:`configuring_easybuild`. +For the ``pip`` install, you may wish to slightly change this command depending on the context and your personal preferences: -.. XXX - UPDATE BY VERSION +* to install EasyBuild *system-wide*, you can use ``sudo`` (if you have admin privileges): -.. tip:: + .. code:: sh - The bootstrap script will only succeed if command ``module --version`` reports a sufficiently recent version - (e.g., environments-modules-c >=v3.2.10 or Lmod >= 5.6.3), because modules are applied throughout, - e.g., to resolve dependencies and detect already installed software. + sudo pip install easybuild -Normally, only when the above fails to work for you for some reason, should you resort -to one of the alternative approaches documented at :ref:`alt_inst_methods` -(these are more involved but also they may give more control). +* To install EasyBuild *in your personal home directory*, you can use the ``--user`` option: -Sanity check + .. code:: sh + + pip install --user easybuild + + This will result in an EasyBuild installation in ``$HOME/.local/``. + +* To install EasyBuild in a *specific directory* you can use the ``--prefix`` option: + + .. code:: sh + + pip install --prefix _PREFIX_ easybuild + + In this command, you should replace '``_PREFIX_``' with the location where you want to have EasyBuild installed + (for example, ``$HOME/tools`` or ``/tmp/$USER``). + +Keep in mind that you may need to update your environment too when using ``--user`` or ``--prefix``, +see :ref:`more_pip_env`. + + +.. _more_pip_pip3: + +``pip`` vs ``pip3`` ~~~~~~~~~~~~ -Compare the version of ``eb``, the main EasyBuild command, with the version of the EasyBuild module that was installed. -For example:: +On systems where both Python 2 and Python 3 are installed you may also have different ``pip`` commands +available. Or maybe ``pip`` is not available at all, and only "versioned" ``pip`` commands like ``pip3`` are +available. - $ module load EasyBuild - $ module list +If you (only) have ``pip3`` available, you can replace ``pip`` with ``pip3`` in any of the ``pip install`` commands +above: - Currently Loaded Modules: - 1) EasyBuild/1.16.1 +.. code:: sh - $ eb --version - This is EasyBuild 1.16.1 (framework: 1.16.1, easyblocks: 1.16.1) on host example.local + pip3 install easybuild -.. tip:: +If you want to ensure that you are using the ``pip`` installation that corresponds to the Python 3 installation +that you intend to use, you can use ``python3 -m pip`` rather than ``pip3``. - The Tcl-based or Lmod implementations of environment modules do their default sorting differently. - The former will normally sort in the lexicographic order, while Lmod follows - an approach that is closer to Python's construct ``LooseVersion`` way of ordering. Such aspects - may make a big difference, if you have installed both versions 1.9.0 and 1.15.2, - with respect to what is the version being loaded by default. +.. code:: sh -.. _install_running_unit_tests: + python3.6 -m pip install easybuild -Running unit tests -~~~~~~~~~~~~~~~~~~ +Note that you may also need to instruct the ``eb`` command to use the correct Python version at runtime, +via ``$EB_PYTHON`` (see :ref:`more_pip_env_EB_PYTHON`). -After completion of the bootstrap procedure and loading the -``EasyBuild`` module, try running the EasyBuild unit tests:: +.. _more_pip_env: - # specify modules tool to use: Lmod *(default)*, EnvironmentModules, EnvironmentModulesC, or EnvironmentModulesTcl - # see also http://easybuild.readthedocs.org/en/latest/Configuration.html#modules-tool-modules-tool - export TEST_EASYBUILD_MODULES_TOOL=Lmod +Updating your environment +~~~~~~~~~~~~ - # run full unit test suite for EasyBuild framework - python -m test.framework.suite +If you used the ``--user`` or ``--prefix`` option in the ``pip install`` command, +or if you installed EasyBuild with a ``pip`` version that does not correspond +to your default Python installation, you will need to update your environment to make EasyBuild ready for use. +This is not required if you did a system-wide installation in a standard location with the default Python version. -Keep in mind that this is just an example, more details about the EasyBuild unit tests are available at :ref:`unit_tests`. +.. note:: + Keep in mind that you will have to make these environment changes again if you start a new shell session. + To avoid this, you can update one of the shell startup scripts in your home directory (``.bashrc`` for example). -If this does not complete successfully, `please open an issue`_ to report it. +.. _more_pip_env_PATH: -.. _please open an issue: https://github.com/easybuilders/easybuild-framework/issues/new +Updating ``$PATH`` +~~~~~~~~~~~~ +Update the ``$PATH`` environment variable to make sure the ``eb`` command is available:: -Example bootstrap run -~~~~~~~~~~~~~~~~~~~~~ + export PATH=_PREFIX_/bin:$PATH -Example output for bootstrapping EasyBuild v1.16.1:: +**Replace** ``_PREFIX_`` **in this command** with the directory path where EasyBuild was installed into +(use ``$HOME/.local`` if you used ``pip install --user``). - [[INFO]] Found module command 'lmod' (Lmod), so using it. - [[INFO]] - - +++ STAGE 0: installing distribute via included (patched) distribute_setup.py... - - - Downloading http://pypi.python.org/packages/source/d/distribute/distribute-0.6.34.tar.gz - Extracting in /tmp/tmpz0zyAG - Now working in /tmp/tmpz0zyAG/distribute-0.6.34 - Installing Distribute - [[INFO]] +This is not required if you installing EasyBuild in a standard system location. - +++ STAGE 1: installing EasyBuild in temporary dir with easy_install... - - - Installing with setuptools.setup... - Installing version 1.16.1 - warning: install_lib: 'build/lib' does not exist -- no Python modules to install +You can check with the ``which eb`` command to determine whether or not you need to update the ``$PATH`` environment variable. - zip_safe flag not set; analyzing archive contents... - Installing with setuptools.setup... - Installing version 1.16.1 (API version 1) - Installing with setuptools.setup... - Installing version 1.16.1 (required versions: API >= 1) - Installing with setuptools.setup... - Installing version 1.16.1.0 (required versions: API >= 1, easyblocks >= 1.16) - warning: install_lib: 'build/lib' does not exist -- no Python modules to install +.. _more_pip_env_PYTHONPATH: - [[INFO]] +Updating ``$PYTHONPATH`` +~~~~~~~~~~~~ - +++ STAGE 2: installing EasyBuild in /home/example/.local/easybuild with EasyBuild from stage 1... +If you installed EasyBuild to a non-standard location using ``pip install --prefix``, +you also need to update the Python search path environment variable ``$PYTHONPATH`` to instruct Python where +it can find the EasyBuild Python packages. +This is not required if you used the ``--user`` option, since Python will automatically consider +``$HOME/.local`` when searching for installed Python packages, or if you installed EasyBuild in a standard +system-wide location. - Couldn't import dot_parser, loading of dot files will not be possible. - == temporary log file in case of crash /tmp/easybuild-zql_Ft/easybuild-peQ8GA.log - == processing EasyBuild easyconfig /tmp/tmp_gzHPM/EasyBuild-1.16.1.eb - == building and installing EasyBuild/1.16.1... - == fetching files... - == creating build dir, resetting environment... - == unpacking... - == patching... - == preparing... - == configuring... - == building... - == testing... - == installing... - == taking care of extensions... - == packaging... - == postprocessing... - == sanity checking... - == cleaning up... - == creating module... - == COMPLETED: Installation ended successfully - == Results of the build can be found in the log file /home/example/.local/easybuild/software/EasyBuild/1.16.1/easybuild/easybuild-EasyBuild-1.16.1-20150220.210610.log - == Build succeeded for 1 out of 1 - == temporary log file /tmp/easybuild-zql_Ft/easybuild-peQ8GA.log has been removed. - == temporary directory /tmp/easybuild-zql_Ft has been removed. - [[INFO]] Done! - [[INFO]] - [[INFO]] EasyBuild v1.16.1 was installed to /home/example/.local/easybuild, so make sure your $MODULEPATH includes /home/example/.local/easybuild/modules/all - [[INFO]] - [[INFO]] Run 'module load EasyBuild', and run 'eb --help' to get help on using EasyBuild. - [[INFO]] Set $EASYBUILD_MODULES_TOOL to 'Lmod' to use the same modules tool as was used now. - [[INFO]] - [[INFO]] By default, EasyBuild will install software to $HOME/.local/easybuild. - [[INFO]] To install software with EasyBuild to /home/example/.local/easybuild, make sure $EASYBUILD_INSTALLPATH is set accordingly. - [[INFO]] See http://easybuild.readthedocs.org/en/latest/Configuration.html for details on configuring EasyBuild. +Update ``$PYTHONPATH`` by running a command like:: + export PYTHONPATH=_PREFIX_/lib/pythonX.Y/site-packages:$PYTHONPATH -After the bootstrap completes, the installed ``EasyBuild`` module can be loaded:: +Here, you need to replace the ``X`` and ``Y`` with the major and minor version of your Python installation, +which you can determine by running ``python -V``. +For example, if you are using Python 3.6, make sure you are using ``/python3.6/`` in the command to update ``$PYTHONPATH``. - $ module use $HOME/.local/easybuild/modules/all - $ module av - ------------------------- /home/example/.local/easybuild/modules/all -------------------------- - EasyBuild/1.16.1 +And of course, you again need to **replace '``_PREFIX_``'** with the installation prefix where EasyBuild was installed +into. - $ module load EasyBuild - $ module list - Currently Loaded Modulefiles: - 1) EasyBuild/1.16.1 +For example:: - $ which eb - /home/example/.local/easybuild/software/EasyBuild/1.16.1/bin/eb + # update $PYTHONPATH if EasyBuild was installed in $HOME/tools with Python 3.6 + export PYTHONPATH=$HOME/tools/lib/python3.6/site-packages:$PYTHONPATH - $ eb --version - This is EasyBuild 1.16.1 (framework: 1.16.1, easyblocks: 1.16.1) on host example.local. +.. _more_pip_env_EB_PYTHON: -Now, enjoy! +Setting ``$EB_PYTHON`` +~~~~~~~~~~~~ -.. _bootstrap_advanced_options: +If you want to control which Python version is used to run EasyBuild, +you can specify the name or the full path to the ``python`` command that should be used by the ``eb`` command +via the ``$EB_PYTHON`` environment variable. -Advanced bootstrapping options ------------------------------- +This may be required when you installing EasyBuild with a version of ``pip`` that does not correspond +with the default Python version. -To use these advanced options, make sure you are using the latest version of the bootstrap script, available -at https://raw.githubusercontent.com/easybuilders/easybuild-framework/develop/easybuild/scripts/bootstrap_eb.py . +For example, to ensure that ``eb`` uses ``python3.6``:: -Skipping the installation of ``easy_install`` (stage 0) -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + export EB_PYTHON=python3.6 -The first stage of the bootstrap procedure consists of installing a specific version of the -``distribute`` Python package, which provides the ``easy_install`` installation tool for Python software, -in a temporary location. The bootstrap script then tries to ensure this particular installation is used -during the other bootstrap stages. -If you already have a version of ``easy_install`` on your system, and if you are confident that it behaves (in particular, -that it complies to the installation prefix specified via ``--prefix``), you can skip stage 0 of the bootstrap procedure. +.. _more_pip_env_EB_VERBOSE: -To do so, simply define the ``EASYBUILD_BOOTSTRAP_SKIP_STAGE0`` environment variable (the value doesn't matter):: +Setting ``$EB_VERBOSE`` +~~~~~~~~~~~~ - $ export EASYBUILD_BOOTSTRAP_SKIP_STAGE0=1 - $ python bootstrap_eb.py $HOME/eb/test_nostage0 - ... - [[INFO]] Skipping stage0, using local distribute/setuptools providing easy_install - ... +To determine which ``python`` commands are being considered by the ``eb`` command, +you can define the ``$EB_VERBOSE`` environment variable. For example:: - +++ STAGE 1: installing EasyBuild in temporary dir with easy_install... + $ EB_VERBOSE=1 eb --version + >> Considering 'python3.6'... + >> 'python3' version: 3.6.8, which matches Python 3 version requirement (>= 3.5) + >> Selected Python command: python3 (/usr/bin/python3.6) + >> python3.6 -m easybuild.main --version + This is EasyBuild 4.3.3 (framework: 4.3.3, easyblocks: 4.3.3) on host example - ... -.. _bootstrap_offline: +.. _eb_as_module: -Offline bootstrapping using supplied source tarballs -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Installing EasyBuild with EasyBuild +----------------------- -By default, the bootstrap script will download the most recent (stable) EasyBuild version from PyPI, the Python Package -Index (https://pypi.python.org/pypi). +If you prefer having EasyBuild available through an environment module file, +you can consider installing EasyBuild with EasyBuild. This can be done in 3 steps: -Recent versions of the bootstrap script also allow to supply source tarballs for the different EasyBuild components -(framework, easyblocks, easyconfigs), and (optionally) the vsc-base and vsc-install libraries EasyBuild depends on. +* Step 1: Installing EasyBuild with ``pip`` into a temporary location (only needed if EasyBuild is not installed yet) +* Step 2: Using EasyBuild to install EasyBuild as a module +* Step 3: Loading the EasyBuild module -The source tarball filenames must match a pattern like ``*.tar.gz``, where ```` denotes the name of the -respective EasyBuild component: - - * ``vsc-install*.tar.gz`` (*must* be downloaded from PyPI, see note below) - * ``vsc-base*.tar.gz`` (*must* be downloaded from PyPI, see note below) - * ``easybuild-framework*.tar.gz`` - * ``easybuild-easyblocks*.tar.gz`` - * ``easybuild-easyconfigs*.tar.gz`` +.. _eb_as_module_step1: -The location of the source tarballs can be specified using the ``$EASYBUILD_BOOTSTRAP_SOURCEPATH`` environment variable. +Step 1: Installing EasyBuild into a temporary location +~~~~~~~~~~~~ -.. note:: The source tarballs for ``vsc-base`` and ``vsc-install`` *must* be downloaded from PyPI rather than GitHub, - since the source tarballs published via PyPi are pre-processed, as opposed to the 'raw' source tarballs - that are available on GitHub. +If you don't have EasyBuild installed yet, you need to install it in a temporary location first. +The recommended way of doing this is using :ref:`pip`. - To download the source tarballs from PyPI, visit https://pypi.python.org/pypi/vsc-base or - https://pypi.python.org/pypi/vsc-install. Alternatively, you can download the source tarball for the - most recent version using pip, for example:: +For example, to install EasyBuild into a subdirectory ``/tmp/$USER`` using the default Python 3 version:: - pip download vsc-base --no-deps + # pick installation prefix, and install EasyBuild into it + export EB_TMPDIR=/tmp/$USER/eb_tmp + python3 -m pip install --ignore-installed --prefix $EB_TMPDIR easybuild -Example usage, with the relevant output at the start of stage 1 of the bootstrap process:: + # update environment to use this temporary EasyBuild installation + export PATH=$EB_TMPDIR/bin:$PATH + export PYTHONPATH=$(/bin/ls -rtd -1 $EB_TMPDIR/lib*/python*/site-packages | tail -1):$PYTHONPATH + export EB_PYTHON=python3 - $ export EASYBUILD_BOOTSTRAP_SOURCEPATH=/tmp/$USER - $ python bootstrap_eb.py $HOME/eb/test_tarballs +.. _eb_as_module_step2: - +++ STAGE 0: installing distribute via included (patched) distribute_setup.py... +Step 2: Using EasyBuild to install EasyBuild +~~~~~~~~~~~~ - ... +Once you have a working (recent) temporary EasyBuild installation, you can use it to +install EasyBuild as a module. Usually this is done in the location where you would +like to install other software too. - +++ STAGE 1: installing EasyBuild in temporary dir with easy_install... +You can use the ``eb --install-latest-eb-release`` command for this, +combined with the ``--prefix`` option to control which directories are used by EasyBuild for the installation. - [[INFO]] Fetching sources from /tmp/example... - [[INFO]] Found /tmp/example/vsc-install-0.10.21.tar.gz for vsc-install package - [[INFO]] Found /tmp/example/vsc-base-2.5.5.tar.gz for vsc-base package - [[INFO]] Found /tmp/example/easybuild-framework-3.0.2.tar.gz for easybuild-framework package - [[INFO]] Found /tmp/example/easybuild-easyblocks.tar.gz for easybuild-easyblocks package - [[INFO]] Found /tmp/example/easybuild-easyconfigs.tar.gz for easybuild-easyconfigs package - ... +For example, to install the latest version of EasyBuild as a module into ``$HOME/easybuild``:: -.. note:: Providing a source tarball for ``vsc-base`` and ``vsc-install` is *optional*. - If not specified, the most recent version available - on PyPI will be downloaded and installed automatically when the ``easybuild-framework`` package is installed. - Source tarballs for all three EasyBuild components *must* be provided when ``$EASYBUILD_BOOTSTRAP_SOURCEPATH`` - is defined, however. + eb --install-latest-eb-release --prefix $HOME/easybuild -.. _updating: +.. note:: -Updating an existing EasyBuild installation -------------------------------------------- + You may see a harmless deprecation warning popping up when performing this installation, just ignore it. + +.. _eb_as_module_step3: -To upgrade to a newer EasyBuild version (say, |version|) than the one currently installed there are several options: +Step 3: Loading the EasyBuild module +~~~~~~~~~~~~ + +Once :ref:`eb_as_module_step2` is completed, you should be able to load the module that was generated alongside +the EasyBuild installation. You will need to do this every time you start a new shell session. + +First, make the module available by running the following command (which will update the module search path +environment variable ``$MODULEPATH``):: - * (re)bootstrap EasyBuild to obtain an ``EasyBuild`` module for version |version|, using the instructions above, see :ref:`bootstrapping`. - * install EasyBuild version |version| with a previous version of EasyBuild + module use _PREFIX_/modules/all - * using ``eb --install-latest-eb-release`` (requires EasyBuild v2.9.0 or more recent), or - * using the easyconfig file available on the develop branch at Github `__ +**Replace** ``_PREFIX_`` with the path to the directory that you used when running :ref:`eb_as_module_step2` +(for example, ``$HOME/easybuild``). + +Then, load the EasyBuild module to update your environment and make EasyBuild available for use:: + + module load EasyBuild + +.. note:: + Note that in this case, we don't need to make any changes to our environment for EasyBuild to work correctly. + The environment module file that was generated by EasyBuild specifies all changes that need to be made. - * install EasyBuild version |version| from PyPI, using one of the standard Python installation tools (``easy_install``, ``pip``, ...), see also :ref:`alt_inst_easy_install_pip` - * update the ``main`` branch of your Git working copies of the different EasyBuild repositories .. _dependencies: @@ -387,11 +350,14 @@ Required dependencies * `Python `_: - * Python 2.7, or Python 3.x (>= 3.5) + * Python 2.7, or Python 3.x (>= 3.5); + + * since Python 2 is end-of-life (https://www.python.org/doc/sunset-python-2/) we strongly recommend + using Python 3 if it is available; - * no third-party Python packages are strictly required (the Python standard library is sufficient) + * no third-party Python packages are strictly required (the Python standard library is sufficient); - * for some *specific* EasyBuild features additional Python packages are required however, see :ref:`optional_python_packages` + * for some *specific* EasyBuild features additional Python packages are required however, see :ref:`optional_python_packages`; * a **modules tool**: Tcl(/C) environment modules or Lmod