Import the ATLAS specific flake8 plugins. Previous location was:
https://gitlab.cern.ch/atlas/athena/tree/master/Tools/PyUtils/python/flake8_atlas

Changes compared to previous version:
- Follow Python packaging guidelines
- Standalone unit tests
- Build the project using `pip`
- Also installable locally via `pip install`
- Some bugfixes for individual checks

Now that BAT could be built, the next step was to make sure that
KLFitter would build as well. Which actually unearthed a previous
build problem. Previously we were building KLFitter in C++03 mode.
Which only worked with the C++14 version of ROOT / BAT by blind
luck...

I had to remove the explicit declarations of the possibly thrown
exceptions from just one of the classes in the code.

Conflicts:
	External/BAT/CMakeLists.txt

With GCC 8 one strncpy(...) call in the XRootD source produces a warning
from -Wstringop-truncation. Which, because of the usage of -Werror in
the build, results in a build failure.

But I checked, the code that produces the warning/error, is safe. The
resulting string always ends up being null-terminated, the XRootD
developers made sure of that.

Since tweaking the XRootD build flags through CMake is almost impossible,
as the flags are set up in a very hardcoded way in XRootD's CMake
configuration, it seemed best to just disable this flag for the one
source file that produced it. (And in which I checked that the code
was actually working correctly.)

I'm actually a bit surprised that the C++14 based analysis release
builds didn't run into any issues so far. :-/

- Change to official ATLAS pip repository
- Remove the extensions module as this is not used anymore (last
  remaining client was PyUtils that has been migrated away)

Migrated to `pip` for external python package build and installation.
The source of the packages is still

http://cern.ch/atlas-software-dist-eos/externals/PyModules

but this area is now organized as a proper PyPA repository following
https://packaging.python.org/guides/hosting-your-own-index.

The advantages over the use of `setuptools` are:
- Rely on `pip` to resolve the dependencies. We just need to make sure
  that the required dependencies are either available via LCG or
  manually added to the above repository.
- There is no global `easy-install.pth` file to be maintained and we can
  install python modules via multiple packages (e.g. PyAnalysis,
  PyModules) into the same installation area without the need of a
  post-build merge.
- The executable scripts created by `setuptools` are not optimal in our
  environment (see https://gitlab.com/pycqa/flake8/issues/537).

The `pip install` command is run with several additional options:
- `--user`: This is the main "trick" to get `pip` install everything into
  our temporary installation directory (set by `$PYTHONUSERBASE`). The
  advantage over using `--prefix` is that `pip` will never try to
  "uninstall" outdated dependencies coming e.g. from the read-only LCG
  area. Instead it will simply install the newer version.
- `--index-url`: Use our own repository as the one and only repository
  to look for packages and dependencies.
- `--disable-pip-version-check`: Disables version check of the `pip`
  executable itself
- `--no-warn-script-location`: Disable check that installed executables
  are indeed on `$PATH`. Since we install into a temporary directory
  first, this warning is always triggered.
- `--no-warn-conflicts`: Without this `pip` would warn about any
  existing conflicts (e.g. within the packages from LCG).
- `--no-cache-dir`: By default `pip` caches downloaded files and build
  products in `~/.cache/pip`. This speeds up subsequent builds but
  since we have `cmake` to take care of that it is probably better to
  disable this to avoid any chance of cross-talk.

To avoid issues with concurrent pip installations, we use a single `pip
install` command (using a requirements file) to do the installation. We
loose the ability to install the modules in parallel but it is
questionable if pip properly supports that to begin with.

Since this package allows a bunch of python modules to build themselves
in parallel, we need to be careful with how we install them from their
temporary installation directory into the CMake build directory.

Instead of doing that installation separately with each python module's
build, the package now has a single target that does this installation.
Which only runs once all the python modules finished building/installing
themselves into that temporary installation directory.

If we had PACKAGE/PACKAGE/ATLAS_CHECK_THREAD_SAFETY and we searched
starting from PACKAGE/test/../src, then we would fail to find the file.
This affected some test code.  Should be fixed now.

Attribute scopes didn't work correctly for gcc versions prior to 7, so we
had to put all our attributes in the `gnu' scope.  Now that we're not
supporting gcc versions earlier than 8, also make the attributes available
in the `ATLAS' scope.  The macros in checker_macros.h will be updated
in the future.

Update URLs given in diagnostics to point to the documentation as maintained
in gitlab, rather than twiki.  Also clean up a small bit of duplicated code.

Don't complain about unchecked calls to GeoModelKernel.

Warn about some cases where we fetch the current EventContext from TLS
(either explicitly or implicitly) even though we already have it available
as a function parameter.

External/scripts is the new location for scripts to be used
during the build of the "External" packages.

- Switch to SHA256 for hash as that one is readily available on pypi.org
  for each package.
- Install binaries into final destination
- Use sanitizer script from PyAnalysis
- Update versions of flake8 and dependencies

Update KLFitter to v1.3.2

See merge request !479

(cherry picked from commit 12bc547f)

8d51c5d1 Update KLFitter to v1.3.1
93e31c0d Update KLFitter to v1.3.2

Make sure to only replace the first line of a script if it is actually a
shebang (#!). Also don't fail if a non-matching glob is given.

Move code for building additional python modules from athena repository
(Exernals/AtlasPyFwdBwdPorts) into externals repo as PyModules.

The list of which modules to build has been revised, with
unused modules removed and versions of active modules updated to
the latest releases. See https://its.cern.ch/jira/browse/ATLINFR-2325
for further details.

Source tarballs are now no longer stored in the git repository, but
are retrieved from
http://cern.ch/atlas-software-dist-eos/externals/PyModules.

Mainly to make it properly functional on macOS. But it should help on other
non-linux platforms as well.

Unfortunately the TBB makefiles are not working correctly on such
a platform, they need to be patched a bit. See ROOT-9678 for more
information.

Now that we can use C++17 with the new version of Eigen that we pick
up from LCG as well.

First to make sure that the build uses all available CPU cores efficiently,
and then updated the build setup of resolveAtlasAddr2Line to take the
recent changes in atlas_add_executable(...) into account.

Now require gcc 8 or later.

We were generating a false positive for this:

```
const int* i1_create();
void i1() {
  static const int& r [[maybe_unused]] = *i1_create();
}
```

because the reference type itself isn't TREE_READONLY.
But references don't take const qualifiers (they're in a sense implicitly
const).  Have the const check look at the target type of the reference
rather than at the reference itself.

(Thanks to Frank W. for reporting.)