summaryrefslogtreecommitdiff
path: root/libraries
diff options
context:
space:
mode:
authorSerban Udrea <S.Udrea@gsi.de>2022-11-05 06:49:11 +0000
committerWilly Sudiarto Raharjo <willysr@slackbuilds.org>2022-11-05 21:15:13 +0700
commit5527dfdb790590f04bc601a23183387839d9c4c5 (patch)
tree386f9fab7cd1064f71e3c9a2448f28decfb55277 /libraries
parente7b16a8c3bc6a6cfa50197b820d416e76606050c (diff)
downloadslackbuilds-5527dfdb790590f04bc601a23183387839d9c4c5.tar.gz
libraries/python2-matplotlib: Added (a Python 2D plotting library)
Signed-off-by: Willy Sudiarto Raharjo <willysr@slackbuilds.org>
Diffstat (limited to 'libraries')
-rw-r--r--libraries/python2-matplotlib/README26
-rw-r--r--libraries/python2-matplotlib/python2-matplotlib.SlackBuild111
-rw-r--r--libraries/python2-matplotlib/python2-matplotlib.info10
-rw-r--r--libraries/python2-matplotlib/setupext.py2249
-rw-r--r--libraries/python2-matplotlib/slack-desc19
5 files changed, 2415 insertions, 0 deletions
diff --git a/libraries/python2-matplotlib/README b/libraries/python2-matplotlib/README
new file mode 100644
index 0000000000..ef592d939f
--- /dev/null
+++ b/libraries/python2-matplotlib/README
@@ -0,0 +1,26 @@
+Matplotlib strives to produce publication quality 2D graphics for
+interactive graphing, scientific publishing, user interface development
+and web application servers targeting multiple user interfaces and
+hardcopy output formats. The 'pylab' mode of ipython uses matplotlib
+to emulate matlab graphics.
+
+OPTIONAL DEPENDENCIES: pytest, mock, ffmpeg/avconv, Inkscape,
+ wxPython3
+
+NOTES: The optional wxagg backend is disabled by default because
+ of possible issues related to wxPython versions. If you wish to
+ use this backend install wxPython3 in advance and set
+ DISABLE_WXAGG to "no" when executing the SlackBuild.
+
+ IMPORTANT: There is some interaction between wxPython and
+ wxPython3, pay attention to the corresponding
+ README files.
+
+ If you want to enable the optional subpackages tests and
+ toolkits_tests you need to set the variable ENABLE_TESTS to
+ "yes" when executing the SlackBuild and make sure that pytest,
+ mock, ffmpeg/avconv and Inkscape are already installed. Besides
+ ffmpeg/avconv are also needed if you wish better support of
+ animation output formats.
+
+ Version 2.2.5 is the last available for python2.
diff --git a/libraries/python2-matplotlib/python2-matplotlib.SlackBuild b/libraries/python2-matplotlib/python2-matplotlib.SlackBuild
new file mode 100644
index 0000000000..ea329da139
--- /dev/null
+++ b/libraries/python2-matplotlib/python2-matplotlib.SlackBuild
@@ -0,0 +1,111 @@
+#!/bin/bash
+
+# Slackware build script for matplotlib
+
+# Copyright 2011-2022 Serban Udrea <s.udrea@gsi.de>
+# All rights reserved.
+#
+# Redistribution and use of this script, with or without modification,
+# is permitted provided that the following conditions are met:
+#
+# 1. Redistributions of this script must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+# Written by Aleksandar Samardzic <asamardzic@gmail.com>
+# Updated to 0.99.1.2 by João Felipe Santos <joao.eel@gmail.com>
+# Patch for libpng borrowed from Arch Linux (no longer needed, 2016.08.28, S.U.)
+# Updated up to version 2.2.5 by Serban Udrea <S.Udrea@gsi.de>
+
+cd $(dirname $0) ; CWD=$(pwd)
+
+PRGNAM=python2-matplotlib
+SRCNAM=matplotlib
+VERSION=${VERSION:-2.2.5}
+BUILD=${BUILD:-1}
+TAG=${TAG:-_SBo}
+PKGTYPE=${PKGTYPE:-tgz}
+
+TARBALL_VERSION=${TARBALL_VERSION:-2.2.5} # Tarball may have wrong versioning
+ENABLE_TESTS=${ENABLE_TESTS:-N}
+DISABLE_WXAGG=${DISABLE_WXAGG:-Y}
+
+if [ -z "$ARCH" ]; then
+ case "$( uname -m )" in
+ i?86) ARCH=i586 ;;
+ arm*) ARCH=arm ;;
+ *) ARCH=$( uname -m ) ;;
+ esac
+fi
+
+# If the variable PRINT_PACKAGE_NAME is set, then this script will report what
+# the name of the created package would be, and then exit. This information
+# could be useful to other scripts.
+if [ ! -z "${PRINT_PACKAGE_NAME}" ]; then
+ echo "$PRGNAM-$VERSION-$ARCH-$BUILD$TAG.$PKGTYPE"
+ exit 0
+fi
+
+TMP=${TMP:-/tmp/SBo}
+PKG=${PKG:-$TMP/package-$PRGNAM}
+OUTPUT=${OUTPUT:-/tmp}
+
+set -e
+
+rm -rf $PKG
+mkdir -p $TMP $PKG $OUTPUT
+cd $TMP
+rm -rf $SRCNAM-$TARBALL_VERSION
+tar xvf $CWD/$SRCNAM-$VERSION.tar.gz
+cd $SRCNAM-$TARBALL_VERSION
+chown -R root:root .
+find -L . \
+ \( -perm 777 -o -perm 775 -o -perm 750 -o -perm 711 -o -perm 555 \
+ -o -perm 511 \) -exec chmod 755 {} \; -o \
+ \( -perm 666 -o -perm 664 -o -perm 640 -o -perm 600 -o -perm 444 \
+ -o -perm 440 -o -perm 400 \) -exec chmod 644 {} \;
+
+ENABLE_TESTS=$(echo "$ENABLE_TESTS"|cut -b 1|tr a-z A-Z)
+DISABLE_WXAGG=$(echo "$DISABLE_WXAGG"|cut -b 1|tr a-z A-Z)
+cat setup.cfg.template > setup.cfg
+
+if [ "$ENABLE_TESTS" = "Y" ]
+then
+ sed -i "s|#tests = False|tests = True|" setup.cfg
+fi
+
+if [ "$DISABLE_WXAGG" = "Y" ]
+then
+ sed -i "s|#wxagg = auto|wxagg = False|" setup.cfg
+fi
+
+# Use modified setupext.py to make sure that the build process gets
+# interrupted if requirements are not fulfilled
+#
+cat "${CWD}/setupext.py" > setupext.py
+
+python2 setup.py install --root $PKG # > ${CWD}/SETUP.OUTPUT 2>&1
+
+find $PKG | xargs file | grep -e "executable" -e "shared object" | grep ELF \
+ | cut -f 1 -d : | xargs strip --strip-unneeded 2> /dev/null || true
+
+mkdir -p $PKG/usr/doc/$PRGNAM-$VERSION
+cp -a INSTALL.rst MANIFEST.in README.rst PKG-INFO $PKG/usr/doc/$PRGNAM-$VERSION
+cat $CWD/$PRGNAM.SlackBuild > $PKG/usr/doc/$PRGNAM-$VERSION/$PRGNAM.SlackBuild
+
+mkdir -p $PKG/install
+cat $CWD/slack-desc > $PKG/install/slack-desc
+
+cd $PKG
+/sbin/makepkg -l y -c n $OUTPUT/$PRGNAM-$VERSION-$ARCH-$BUILD$TAG.$PKGTYPE
diff --git a/libraries/python2-matplotlib/python2-matplotlib.info b/libraries/python2-matplotlib/python2-matplotlib.info
new file mode 100644
index 0000000000..c7893768f3
--- /dev/null
+++ b/libraries/python2-matplotlib/python2-matplotlib.info
@@ -0,0 +1,10 @@
+PRGNAM="python2-matplotlib"
+VERSION="2.2.5"
+HOMEPAGE="https://matplotlib.org/"
+DOWNLOAD="https://files.pythonhosted.org/packages/10/5f/10c310c943f29e67976dcc26dccf9305a5a9bc7483e631ee74a0f95aa5b2/matplotlib-2.2.5.tar.gz"
+MD5SUM="422fc58e7323b7ba3f19382424f9ab7b"
+DOWNLOAD_x86_64=""
+MD5SUM_x86_64=""
+REQUIRES="python2-numpy python2-dateutil pytz python2-cycler functools-lru-cache subprocess32 python2-kiwisolver tornado"
+MAINTAINER="Serban Udrea"
+EMAIL="S.Udrea@gsi.de"
diff --git a/libraries/python2-matplotlib/setupext.py b/libraries/python2-matplotlib/setupext.py
new file mode 100644
index 0000000000..bf931378d6
--- /dev/null
+++ b/libraries/python2-matplotlib/setupext.py
@@ -0,0 +1,2249 @@
+from __future__ import print_function, absolute_import
+
+from importlib import import_module
+
+from distutils import sysconfig
+from distutils import version
+from distutils.core import Extension
+import hashlib
+
+import distutils.command.build_ext
+from io import BytesIO
+
+import glob
+import multiprocessing
+import os
+import platform
+
+import re
+
+import setuptools
+import shutil
+
+import subprocess
+from subprocess import check_output
+import sys
+import warnings
+from textwrap import fill
+import shutil
+
+import tarfile
+import textwrap
+
+import versioneer
+import warnings
+import contextlib
+
+if sys.version_info < (3, ):
+ from urllib2 import urlopen, Request
+
+ class FileExistsError(OSError):
+ pass
+
+ def makedirs(path, exist_ok=True):
+ if not exist_ok:
+ raise ValueError("this backport only supports exist_ok is True")
+ if not path or os.path.exists(path):
+ return
+ head, tail = os.path.split(path)
+
+ makedirs(head, exist_ok=True)
+ os.makedirs(path)
+
+else:
+ from urllib.request import urlopen, Request
+ from os import makedirs
+
+
+PY3min = (sys.version_info[0] >= 3)
+
+
+def _get_xdg_cache_dir():
+ """
+ Return the XDG cache directory.
+
+ See https://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+ """
+ cache_dir = os.environ.get('XDG_CACHE_HOME')
+ if not cache_dir:
+ cache_dir = os.path.expanduser('~/.cache')
+ if cache_dir.startswith('~/'): # Expansion failed.
+ return None
+ return os.path.join(cache_dir, 'matplotlib')
+
+
+def get_fd_hash(fd):
+ """
+ Compute the sha256 hash of the bytes in a file-like
+ """
+ BLOCKSIZE = 1 << 16
+ hasher = hashlib.sha256()
+ old_pos = fd.tell()
+ fd.seek(0)
+ buf = fd.read(BLOCKSIZE)
+ while buf:
+ hasher.update(buf)
+ buf = fd.read(BLOCKSIZE)
+ fd.seek(old_pos)
+ return hasher.hexdigest()
+
+
+def download_or_cache(url, sha):
+ """
+ Get bytes from the given url or local cache.
+
+ Parameters
+ ----------
+ url : str
+ The url to download
+
+ sha : str
+ The sha256 of the file
+
+ Returns
+ -------
+ BytesIO
+ The file loaded into memory.
+ """
+ cache_dir = _get_xdg_cache_dir()
+
+ def get_from_cache(local_fn):
+ if cache_dir is None:
+ raise Exception("no cache dir")
+ cache_filename = os.path.join(cache_dir, local_fn)
+ with open(cache_filename, 'rb') as fin:
+ buf = BytesIO(fin.read())
+ file_sha = get_fd_hash(buf)
+ if file_sha != sha:
+ return None
+ buf.seek(0)
+ return buf
+
+ def write_cache(local_fn, data):
+ if cache_dir is None:
+ raise Exception("no cache dir")
+
+ cache_filename = os.path.join(cache_dir, local_fn)
+ makedirs(cache_dir, exist_ok=True)
+ if sys.version_info < (3, ):
+ if os.path.exists(cache_filename):
+ raise FileExistsError
+ mode = 'wb'
+ else:
+ mode = 'xb'
+ old_pos = data.tell()
+ data.seek(0)
+ with open(cache_filename, mode=mode) as fout:
+ fout.write(data.read())
+ data.seek(old_pos)
+
+ try:
+ return get_from_cache(sha)
+ except Exception:
+ pass
+
+ # jQueryUI's website blocks direct downloads from urllib.request's
+ # default User-Agent, but not (for example) wget; so I don't feel too
+ # bad passing in an empty User-Agent.
+ with contextlib.closing(urlopen(
+ Request(url, headers={"User-Agent": ""}))) as req:
+ file_contents = BytesIO(req.read())
+ file_contents.seek(0)
+
+ file_sha = get_fd_hash(file_contents)
+
+ if file_sha != sha:
+ raise Exception(("The download file does not match the "
+ "expected sha. {url} was expected to have "
+ "{sha} but it had {file_sha}").format(
+ sha=sha, file_sha=file_sha, url=url))
+
+ try:
+ write_cache(sha, file_contents)
+ except Exception:
+ pass
+
+ file_contents.seek(0)
+ return file_contents
+
+
+# SHA256 hashes of the FreeType tarballs
+_freetype_hashes = {
+ '2.6.1': '0a3c7dfbda6da1e8fce29232e8e96d987ababbbf71ebc8c75659e4132c367014',
+ '2.6.2': '8da42fc4904e600be4b692555ae1dcbf532897da9c5b9fb5ebd3758c77e5c2d4',
+ '2.6.3': '7942096c40ee6fea882bd4207667ad3f24bff568b96b10fd3885e11a7baad9a3',
+ '2.6.4': '27f0e38347a1850ad57f84fc4dfed68ba0bc30c96a6fa6138ef84d485dd9a8d7',
+ '2.6.5': '3bb24add9b9ec53636a63ea8e867ed978c4f8fdd8f1fa5ccfd41171163d4249a',
+ '2.7': '7b657d5f872b0ab56461f3bd310bd1c5ec64619bd15f0d8e08282d494d9cfea4',
+ '2.7.1': '162ef25aa64480b1189cdb261228e6c5c44f212aac4b4621e28cf2157efb59f5',
+ '2.8': '33a28fabac471891d0523033e99c0005b95e5618dc8ffa7fa47f9dadcacb1c9b',
+ '2.8.1': '876711d064a6a1bd74beb18dd37f219af26100f72daaebd2d86cb493d7cd7ec6',
+}
+# This is the version of FreeType to use when building a local
+# version. It must match the value in
+# lib/matplotlib.__init__.py and also needs to be changed below in the
+# embedded windows build script (grep for "REMINDER" in this file)
+LOCAL_FREETYPE_VERSION = '2.6.1'
+LOCAL_FREETYPE_HASH = _freetype_hashes.get(LOCAL_FREETYPE_VERSION, 'unknown')
+
+if sys.platform != 'win32':
+ if not PY3min:
+ from commands import getstatusoutput
+ else:
+ from subprocess import getstatusoutput
+
+
+if PY3min:
+ import configparser
+else:
+ import ConfigParser as configparser
+
+
+# matplotlib build options, which can be altered using setup.cfg
+options = {
+ 'display_status': True,
+ 'verbose': False,
+ 'backend': None,
+ 'basedirlist': None
+ }
+
+
+setup_cfg = os.environ.get('MPLSETUPCFG', 'setup.cfg')
+if os.path.exists(setup_cfg):
+ if PY3min:
+ config = configparser.ConfigParser()
+ else:
+ config = configparser.SafeConfigParser()
+ config.read(setup_cfg)
+
+ if config.has_option('status', 'suppress'):
+ options['display_status'] = not config.getboolean("status", "suppress")
+
+ if config.has_option('rc_options', 'backend'):
+ options['backend'] = config.get("rc_options", "backend")
+
+ if config.has_option('directories', 'basedirlist'):
+ options['basedirlist'] = [
+ x.strip() for x in
+ config.get("directories", "basedirlist").split(',')]
+
+ if config.has_option('test', 'local_freetype'):
+ options['local_freetype'] = config.getboolean("test", "local_freetype")
+else:
+ config = None
+
+lft = bool(os.environ.get('MPLLOCALFREETYPE', False))
+options['local_freetype'] = lft or options.get('local_freetype', False)
+
+
+def get_win32_compiler():
+ """
+ Determine the compiler being used on win32.
+ """
+ # Used to determine mingw32 or msvc
+ # This is pretty bad logic, someone know a better way?
+ for v in sys.argv:
+ if 'mingw32' in v:
+ return 'mingw32'
+ return 'msvc'
+win32_compiler = get_win32_compiler()
+
+
+def extract_versions():
+ """
+ Extracts version values from the main matplotlib __init__.py and
+ returns them as a dictionary.
+ """
+ with open('lib/matplotlib/__init__.py') as fd:
+ for line in fd.readlines():
+ if (line.startswith('__version__numpy__')):
+ exec(line.strip())
+ return locals()
+
+
+def has_include_file(include_dirs, filename):
+ """
+ Returns `True` if `filename` can be found in one of the
+ directories in `include_dirs`.
+ """
+ if sys.platform == 'win32':
+ include_dirs = list(include_dirs) # copy before modify
+ include_dirs += os.environ.get('INCLUDE', '.').split(os.pathsep)
+ for dir in include_dirs:
+ if os.path.exists(os.path.join(dir, filename)):
+ return True
+ return False
+
+
+def check_include_file(include_dirs, filename, package):
+ """
+ Raises an exception if the given include file can not be found.
+ """
+ if not has_include_file(include_dirs, filename):
+ raise CheckFailed(
+ "The C/C++ header for %s (%s) could not be found. You "
+ "may need to install the development package." %
+ (package, filename))
+
+
+def get_base_dirs():
+ """
+ Returns a list of standard base directories on this platform.
+ """
+ if options['basedirlist']:
+ return options['basedirlist']
+
+ if os.environ.get('MPLBASEDIRLIST'):
+ return os.environ.get('MPLBASEDIRLIST').split(os.pathsep)
+
+ win_bases = ['win32_static', ]
+ # on conda windows, we also add the <conda_env_dir>\Library,
+ # as conda installs libs/includes there
+ # env var names mess: https://github.com/conda/conda/issues/2312
+ conda_env_path = os.getenv('CONDA_PREFIX') # conda >= 4.1
+ if not conda_env_path:
+ conda_env_path = os.getenv('CONDA_DEFAULT_ENV') # conda < 4.1
+ if conda_env_path and os.path.isdir(conda_env_path):
+ win_bases.append(os.path.join(conda_env_path, "Library"))
+
+ basedir_map = {
+ 'win32': win_bases,
+ 'darwin': ['/usr/local/', '/usr', '/usr/X11',
+ '/opt/X11', '/opt/local'],
+ 'sunos5': [os.getenv('MPLIB_BASE') or '/usr/local', ],
+ 'gnu0': ['/usr'],
+ 'aix5': ['/usr/local'],
+ }
+ return basedir_map.get(sys.platform, ['/usr/local', '/usr'])
+
+
+def get_include_dirs():
+ """
+ Returns a list of standard include directories on this platform.
+ """
+ include_dirs = [os.path.join(d, 'include') for d in get_base_dirs()]
+ if sys.platform != 'win32':
+ # gcc includes this dir automatically, so also look for headers in
+ # these dirs
+ include_dirs.extend(
+ os.environ.get('CPLUS_INCLUDE_PATH', '').split(os.pathsep))
+ return include_dirs
+
+
+def is_min_version(found, minversion):
+ """
+ Returns `True` if `found` is at least as high a version as
+ `minversion`.
+ """
+ expected_version = version.LooseVersion(minversion)
+ found_version = version.LooseVersion(found)
+ return found_version >= expected_version
+
+
+# Define the display functions only if display_status is True.
+if options['display_status']:
+ def print_line(char='='):
+ print(char * 76)
+
+ def print_status(package, status):
+ initial_indent = "%22s: " % package
+ indent = ' ' * 24
+ print(fill(str(status), width=76,
+ initial_indent=initial_indent,
+ subsequent_indent=indent))
+
+ def print_message(message):
+ indent = ' ' * 24 + "* "
+ print(fill(str(message), width=76,
+ initial_indent=indent,
+ subsequent_indent=indent))
+
+ def print_raw(section):
+ print(section)
+else:
+ def print_line(*args, **kwargs):
+ pass
+ print_status = print_message = print_raw = print_line
+
+
+# Remove the -Wstrict-prototypes option, is it's not valid for C++
+customize_compiler = distutils.command.build_ext.customize_compiler
+
+
+def my_customize_compiler(compiler):
+ retval = customize_compiler(compiler)
+ try:
+ compiler.compiler_so.remove('-Wstrict-prototypes')
+ except (ValueError, AttributeError):
+ pass
+ return retval
+
+distutils.command.build_ext.customize_compiler = my_customize_compiler
+
+
+def make_extension(name, files, *args, **kwargs):
+ """
+ Make a new extension. Automatically sets include_dirs and
+ library_dirs to the base directories appropriate for this
+ platform.
+
+ `name` is the name of the extension.
+
+ `files` is a list of source files.
+
+ Any additional arguments are passed to the
+ `distutils.core.Extension` constructor.
+ """
+ ext = DelayedExtension(name, files, *args, **kwargs)
+ for dir in get_base_dirs():
+ include_dir = os.path.join(dir, 'include')
+ if os.path.exists(include_dir):
+ ext.include_dirs.append(include_dir)
+ for lib in ('lib', 'lib64'):
+ lib_dir = os.path.join(dir, lib)
+ if os.path.exists(lib_dir):
+ ext.library_dirs.append(lib_dir)
+ ext.include_dirs.append('.')
+
+ return ext
+
+
+def get_buffer_hash(fd):
+ BLOCKSIZE = 1 << 16
+ hasher = hashlib.sha256()
+ buf = fd.read(BLOCKSIZE)
+ while buf:
+ hasher.update(buf)
+ buf = fd.read(BLOCKSIZE)
+
+ return hasher.hexdigest()
+
+
+class PkgConfig(object):
+ """
+ This is a class for communicating with pkg-config.
+ """
+ def __init__(self):
+ """
+ Determines whether pkg-config exists on this machine.
+ """
+ if sys.platform == 'win32':
+ self.has_pkgconfig = False
+ else:
+ try:
+ self.pkg_config = os.environ['PKG_CONFIG']
+ except KeyError:
+ self.pkg_config = 'pkg-config'
+
+ self.set_pkgconfig_path()
+ status, output = getstatusoutput(self.pkg_config + " --help")
+ self.has_pkgconfig = (status == 0)
+ if not self.has_pkgconfig:
+ print("IMPORTANT WARNING:")
+ print(
+ " pkg-config is not installed.\n"
+ " matplotlib may not be able to find some of its dependencies")
+
+ def set_pkgconfig_path(self):
+ pkgconfig_path = sysconfig.get_config_var('LIBDIR')
+ if pkgconfig_path is None:
+ return
+
+ pkgconfig_path = os.path.join(pkgconfig_path, 'pkgconfig')
+ if not os.path.isdir(pkgconfig_path):
+ return
+
+ try:
+ os.environ['PKG_CONFIG_PATH'] += ':' + pkgconfig_path
+ except KeyError:
+ os.environ['PKG_CONFIG_PATH'] = pkgconfig_path
+
+ def setup_extension(self, ext, package, default_include_dirs=[],
+ default_library_dirs=[], default_libraries=[],
+ alt_exec=None):
+ """
+ Add parameters to the given `ext` for the given `package`.
+ """
+ flag_map = {
+ '-I': 'include_dirs', '-L': 'library_dirs', '-l': 'libraries'}
+
+ executable = alt_exec
+ if self.has_pkgconfig:
+ executable = (self.pkg_config + ' {0}').format(package)
+
+ use_defaults = True
+
+ if executable is not None:
+ command = "{0} --libs --cflags ".format(executable)
+
+ try:
+ output = check_output(command, shell=True,
+ stderr=subprocess.STDOUT)
+ except subprocess.CalledProcessError:
+ pass
+ else:
+ output = output.decode(sys.getfilesystemencoding())
+ use_defaults = False
+ for token in output.split():
+ attr = flag_map.get(token[:2])
+ if attr is not None:
+ getattr(ext, attr).insert(0, token[2:])
+
+ if use_defaults:
+ basedirs = get_base_dirs()
+ for base in basedirs:
+ for include in default_include_dirs:
+ dir = os.path.join(base, include)
+ if os.path.exists(dir):
+ ext.include_dirs.append(dir)
+ for lib in default_library_dirs:
+ dir = os.path.join(base, lib)
+ if os.path.exists(dir):
+ ext.library_dirs.append(dir)
+ ext.libraries.extend(default_libraries)
+ return True
+
+ return False
+
+ def get_version(self, package):
+ """
+ Get the version of the package from pkg-config.
+ """
+ if not self.has_pkgconfig:
+ return None
+
+ status, output = getstatusoutput(
+ self.pkg_config + " %s --modversion" % (package))
+ if status == 0:
+ return output
+ return None
+
+
+# The PkgConfig class should be used through this singleton
+pkg_config = PkgConfig()
+
+
+class CheckFailed(Exception):
+ """
+ Exception thrown when a `SetupPackage.check` method fails.
+ """
+ pass
+
+
+class SetupPackage(object):
+ optional = False
+ pkg_names = {
+ "apt-get": None,
+ "yum": None,
+ "dnf": None,
+ "brew": None,
+ "port": None,
+ "windows_url": None
+ }
+
+ def check(self):
+ """
+ Checks whether the build dependencies are met. Should raise a
+ `CheckFailed` exception if the dependency could not be met, otherwise
+ return a string indicating a version number or some other message
+ indicating what was found.
+ """
+ pass
+
+ def runtime_check(self):
+ """
+ True if the runtime dependencies of the backend are met. Assumes that
+ the build-time dependencies are met.
+ """
+ return True
+
+ def get_packages(self):
+ """
+ Get a list of package names to add to the configuration.
+ These are added to the `packages` list passed to
+ `distutils.setup`.
+ """
+ return []
+
+ def get_namespace_packages(self):
+ """
+ Get a list of namespace package names to add to the configuration.
+ These are added to the `namespace_packages` list passed to
+ `distutils.setup`.
+ """
+ return []
+
+ def get_py_modules(self):
+ """
+ Get a list of top-level modules to add to the configuration.
+ These are added to the `py_modules` list passed to
+ `distutils.setup`.
+ """
+ return []
+
+ def get_package_data(self):
+ """
+ Get a package data dictionary to add to the configuration.
+ These are merged into to the `package_data` list passed to
+ `distutils.setup`.
+ """
+ return {}
+
+ def get_extension(self):
+ """
+ Get a list of C extensions (`distutils.core.Extension`
+ objects) to add to the configuration. These are added to the
+ `extensions` list passed to `distutils.setup`.
+ """
+ return None
+
+ def get_install_requires(self):
+ """
+ Get a list of Python packages that we require.
+ pip/easy_install will attempt to download and install this
+ package if it is not installed.
+ """
+ return []
+
+ def get_setup_requires(self):
+ """
+ Get a list of Python packages that we require at build time.
+ pip/easy_install will attempt to download and install this
+ package if it is not installed.
+ """
+ return []
+
+ def _check_for_pkg_config(self, package, include_file, min_version=None,
+ version=None):
+ """
+ A convenience function for writing checks for a
+ pkg_config-defined dependency.
+
+ `package` is the pkg_config package name.
+
+ `include_file` is a top-level include file we expect to find.
+
+ `min_version` is the minimum version required.
+
+ `version` will override the found version if this package
+ requires an alternate method for that. Set version='unknown'
+ if the version is not known but you still want to disabled
+ pkg_config version check.
+ """
+ if version is None:
+ version = pkg_config.get_version(package)
+
+ if version is None:
+ raise CheckFailed(
+ "pkg-config information for '%s' could not be found." %
+ package)
+
+ if min_version == 'PATCH':
+ raise CheckFailed(
+ "Requires patches that have not been merged upstream.")
+
+ if min_version and version != 'unknown':
+ if (not is_min_version(version, min_version)):
+ raise CheckFailed(
+ "Requires %s %s or later. Found %s." %
+ (package, min_version, version))
+
+ ext = self.get_extension()
+ if ext is None:
+ ext = make_extension('test', [])
+ pkg_config.setup_extension(ext, package)
+
+ check_include_file(
+ ext.include_dirs + get_include_dirs(), include_file, package)
+
+ return 'version %s' % version
+
+ def do_custom_build(self):
+ """
+ If a package needs to do extra custom things, such as building a
+ third-party library, before building an extension, it should
+ override this method.
+ """
+ pass
+
+ def install_help_msg(self):
+ """
+ Do not override this method !
+
+ Generate the help message to show if the package is not installed.
+ To use this in subclasses, simply add the dictionary `pkg_names` as
+ a class variable:
+
+ pkg_names = {
+ "apt-get": <Name of the apt-get package>,
+ "yum": <Name of the yum package>,
+ "dnf": <Name of the dnf package>,
+ "brew": <Name of the brew package>,
+ "port": <Name of the port package>,
+ "windows_url": <The url which has installation instructions>
+ }
+
+ All the dictionary keys are optional. If a key is not present or has
+ the value `None` no message is provided for that platform.
+ """
+ def _try_managers(*managers):
+ for manager in managers:
+ pkg_name = self.pkg_names.get(manager, None)
+ if pkg_name:
+ try:
+ # `shutil.which()` can be used when Python 2.7 support
+ # is dropped. It is available in Python 3.3+
+ _ = check_output(["which", manager],
+ stderr=subprocess.STDOUT)
+ if manager == 'port':
+ pkgconfig = 'pkgconfig'
+ else:
+ pkgconfig = 'pkg-config'
+ return ('Try installing {0} with `{1} install {2}` '
+ 'and pkg-config with `{1} install {3}`'
+ .format(self.name, manager, pkg_name,
+ pkgconfig))
+ except subprocess.CalledProcessError:
+ pass
+
+ message = None
+ if sys.platform == "win32":
+ url = self.pkg_names.get("windows_url", None)
+ if url:
+ message = ('Please check {0} for instructions to install {1}'
+ .format(url, self.name))
+ elif sys.platform == "darwin":
+ message = _try_managers("brew", "port")
+ elif sys.platform.startswith("linux"):
+ release = platform.linux_distribution()[0].lower()
+ if release in ('debian', 'ubuntu'):
+ message = _try_managers('apt-get')
+ elif release in ('centos', 'redhat', 'fedora'):
+ message = _try_managers('dnf', 'yum')
+ return message
+
+
+class OptionalPackage(SetupPackage):
+ optional = True
+ force = False
+ config_category = "packages"
+ default_config = "auto"
+
+ @classmethod
+ def get_config(cls):
+ """
+ Look at `setup.cfg` and return one of ["auto", True, False] indicating
+ if the package is at default state ("auto"), forced by the user (case
+ insensitively defined as 1, true, yes, on for True) or opted-out (case
+ insensitively defined as 0, false, no, off for False).
+ """
+ conf = cls.default_config
+ if config is not None and config.has_option(cls.config_category, cls.name):
+ try:
+ conf = config.getboolean(cls.config_category, cls.name)
+ except ValueError:
+ conf = config.get(cls.config_category, cls.name)
+ return conf
+
+ def check(self):
+ """
+ Do not override this method!
+
+ For custom dependency checks override self.check_requirements().
+ Two things are checked: Configuration file and requirements.
+ """
+ # Check configuration file
+ conf = self.get_config()
+ # Default "auto" state or install forced by user
+ if conf in [True, 'auto']:
+ message = "installing"
+ # Set non-optional if user sets `True` in config
+ if conf is True:
+ self.optional = False
+ # Configuration opt-out by user
+ else:
+ # Some backend extensions (e.g. Agg) need to be built for certain
+ # other GUI backends (e.g. TkAgg) even when manually disabled
+ if self.force is True:
+ message = "installing forced (config override)"
+ else:
+ raise CheckFailed("skipping due to configuration")
+
+ # Check requirements and add extra information (if any) to message.
+ # If requirements are not met a CheckFailed should be raised in there.
+ additional_info = self.check_requirements()
+ if additional_info:
+ message += ", " + additional_info
+
+ # No CheckFailed raised until now, return install message.
+ return message
+
+ def check_requirements(self):
+ """
+ Override this method to do custom dependency checks.
+
+ - Raise CheckFailed() if requirements are not met.
+ - Return message with additional information, or an empty string
+ (or None) for no additional information.
+ """
+ return ""
+
+
+class OptionalBackendPackage(OptionalPackage):
+ config_category = "gui_support"
+
+
+class Platform(SetupPackage):
+ name = "platform"
+
+ def check(self):
+ return sys.platform
+
+
+class Python(SetupPackage):
+ name = "python"
+
+ def check(self):
+ major, minor1, minor2, s, tmp = sys.version_info
+
+ if major < 2:
+ raise CheckFailed(
+ "Requires Python 2.7 or later")
+ elif major == 2 and minor1 < 7:
+ raise CheckFailed(
+ "Requires Python 2.7 or later (in the 2.x series)")
+ elif major == 3 and minor1 < 4:
+ raise CheckFailed(
+ "Requires Python 3.4 or later (in the 3.x series)")
+
+ return sys.version
+
+
+class Matplotlib(SetupPackage):
+ name = "matplotlib"
+
+ def check(self):
+ return versioneer.get_version()
+
+ def get_packages(self):
+ return [
+ 'matplotlib',
+ 'matplotlib.backends',
+ 'matplotlib.backends.qt_editor',
+ 'matplotlib.compat',
+ 'matplotlib.projections',
+ 'matplotlib.axes',
+ 'matplotlib.sphinxext',
+ 'matplotlib.style',
+ 'matplotlib.testing',
+ 'matplotlib.testing._nose',
+ 'matplotlib.testing._nose.plugins',
+ 'matplotlib.testing.jpl_units',
+ 'matplotlib.tri',
+ 'matplotlib.cbook'
+ ]
+
+ def get_py_modules(self):
+ return ['pylab']
+
+ def get_package_data(self):
+ return {
+ 'matplotlib':
+ [
+ 'mpl-data/fonts/afm/*.afm',
+ 'mpl-data/fonts/pdfcorefonts/*.afm',
+ 'mpl-data/fonts/pdfcorefonts/*.txt',
+ 'mpl-data/fonts/ttf/*.ttf',
+ 'mpl-data/fonts/ttf/LICENSE_STIX',
+ 'mpl-data/fonts/ttf/COPYRIGHT.TXT',
+ 'mpl-data/fonts/ttf/README.TXT',
+ 'mpl-data/fonts/ttf/RELEASENOTES.TXT',
+ 'mpl-data/images/*.xpm',
+ 'mpl-data/images/*.svg',
+ 'mpl-data/images/*.gif',
+ 'mpl-data/images/*.pdf',
+ 'mpl-data/images/*.png',
+ 'mpl-data/images/*.ppm',
+ 'mpl-data/example/*.npy',
+ 'mpl-data/matplotlibrc',
+ 'backends/web_backend/*.*',
+ 'backends/web_backend/js/*.*',
+ 'backends/web_backend/jquery/js/*.min.js',
+ 'backends/web_backend/jquery/css/themes/base/*.min.css',
+ 'backends/web_backend/jquery/css/themes/base/images/*',
+ 'backends/web_backend/jquery-ui-*/*',
+ 'backends/web_backend/jquery-ui-*/*/*',
+ 'backends/web_backend/jquery-ui-*/*/*/*',
+ 'backends/web_backend/css/*.*',
+ 'backends/Matplotlib.nib/*',
+ 'mpl-data/stylelib/*.mplstyle',
+ ]}
+
+
+class SampleData(OptionalPackage):
+ """
+ This handles the sample data that ships with matplotlib. It is
+ technically optional, though most often will be desired.
+ """
+ name = "sample_data"
+
+ def get_package_data(self):
+ return {
+ 'matplotlib':
+ [
+ 'mpl-data/sample_data/*.*',
+ 'mpl-data/sample_data/axes_grid/*.*',
+ ]}
+
+
+class Toolkits(OptionalPackage):
+ name = "toolkits"
+
+ def get_packages(self):
+ return [
+ 'mpl_toolkits',
+ 'mpl_toolkits.mplot3d',
+ 'mpl_toolkits.axes_grid',
+ 'mpl_toolkits.axes_grid1',
+ 'mpl_toolkits.axisartist',
+ ]
+
+ def get_namespace_packages(self):
+ return ['mpl_toolkits']
+
+
+class Tests(OptionalPackage):
+ name = "tests"
+ pytest_min_version = '3.6'
+ default_config = False
+
+ def check(self):
+ super(Tests, self).check()
+
+ msgs = []
+ msg_template = ('{package} is required to run the Matplotlib test '
+ 'suite. Please install it with pip or your preferred '
+ 'tool to run the test suite')
+
+ bad_pytest = msg_template.format(
+ package='pytest %s or later' % self.pytest_min_version
+ )
+ try:
+ import pytest
+ if is_min_version(pytest.__version__, self.pytest_min_version):
+ msgs += ['using pytest version %s' % pytest.__version__]
+ else:
+ msgs += [bad_pytest]
+ except ImportError:
+ msgs += [bad_pytest]
+
+ if PY3min:
+ msgs += ['using unittest.mock']
+ else:
+ try:
+ import mock
+ msgs += ['using mock %s' % mock.__version__]
+ except ImportError:
+ msgs += [msg_template.format(package='mock')]
+
+ return ' / '.join(msgs)
+
+ def get_packages(self):
+ return [
+ 'matplotlib.tests',
+ 'matplotlib.sphinxext.tests',
+ ]
+
+ def get_package_data(self):
+ baseline_images = [
+ 'tests/baseline_images/%s/*' % x
+ for x in os.listdir('lib/matplotlib/tests/baseline_images')]
+
+ return {
+ 'matplotlib':
+ baseline_images +
+ [
+ 'tests/cmr10.pfb',
+ 'tests/mpltest.ttf',
+ 'tests/test_rcparams.rc',
+ 'tests/test_utf32_be_rcparams.rc',
+ 'sphinxext/tests/tinypages/*.rst',
+ 'sphinxext/tests/tinypages/*.py',
+ 'sphinxext/tests/tinypages/_static/*',
+ ]}
+
+
+class Toolkits_Tests(Tests):
+ name = "toolkits_tests"
+
+ def check_requirements(self):
+ conf = self.get_config()
+ toolkits_conf = Toolkits.get_config()
+ tests_conf = Tests.get_config()
+
+ if conf is True:
+ Tests.force = True
+ Toolkits.force = True
+ elif conf == "auto" and not (toolkits_conf and tests_conf):
+ # Only auto-install if both toolkits and tests are set
+ # to be installed
+ raise CheckFailed("toolkits_tests needs 'toolkits' and 'tests'")
+ return ""
+
+ def get_packages(self):
+ return [
+ 'mpl_toolkits.tests',
+ ]
+
+ def get_package_data(self):
+ baseline_images = [
+ 'tests/baseline_images/%s/*' % x
+ for x in os.listdir('lib/mpl_toolkits/tests/baseline_images')]
+
+ return {'mpl_toolkits': baseline_images}
+
+ def get_namespace_packages(self):
+ return ['mpl_toolkits']
+
+
+class DelayedExtension(Extension, object):
+ """
+ A distutils Extension subclass where some of its members
+ may have delayed computation until reaching the build phase.
+
+ This is so we can, for example, get the Numpy include dirs
+ after pip has installed Numpy for us if it wasn't already
+ on the system.
+ """
+ def __init__(self, *args, **kwargs):
+ super(DelayedExtension, self).__init__(*args, **kwargs)
+ self._finalized = False
+ self._hooks = {}
+
+ def add_hook(self, member, func):
+ """
+ Add a hook to dynamically compute a member.
+
+ Parameters
+ ----------
+ member : string
+ The name of the member
+
+ func : callable
+ The function to call to get dynamically-computed values
+ for the member.
+ """
+ self._hooks[member] = func
+
+ def finalize(self):
+ self._finalized = True
+
+ class DelayedMember(property):
+ def __init__(self, name):
+ self._name = name
+
+ def __get__(self, obj, objtype=None):
+ result = getattr(obj, '_' + self._name, [])
+
+ if obj._finalized:
+ if self._name in obj._hooks:
+ result = obj._hooks[self._name]() + result
+
+ return result
+
+ def __set__(self, obj, value):
+ setattr(obj, '_' + self._name, value)
+
+ include_dirs = DelayedMember('include_dirs')
+
+
+class Numpy(SetupPackage):
+ name = "numpy"
+
+ @staticmethod
+ def include_dirs_hook():
+ if PY3min:
+ import builtins
+ if hasattr(builtins, '__NUMPY_SETUP__'):
+ del builtins.__NUMPY_SETUP__
+ import imp
+ import numpy
+ imp.reload(numpy)
+ else:
+ import __builtin__
+ if hasattr(__builtin__, '__NUMPY_SETUP__'):
+ del __builtin__.__NUMPY_SETUP__
+ import numpy
+ reload(numpy)
+
+ ext = Extension('test', [])
+ ext.include_dirs.append(numpy.get_include())
+ if not has_include_file(
+ ext.include_dirs, os.path.join("numpy", "arrayobject.h")):
+ warnings.warn(
+ "The C headers for numpy could not be found. "
+ "You may need to install the development package")
+
+ return [numpy.get_include()]
+
+ def check(self):
+ min_version = extract_versions()['__version__numpy__']
+ try:
+ import numpy
+ except ImportError:
+ return 'not found. pip may install it below.'
+
+ if not is_min_version(numpy.__version__, min_version):
+ raise SystemExit(
+ "Requires numpy %s or later to build. (Found %s)" %
+ (min_version, numpy.__version__))
+
+ return 'version %s' % numpy.__version__
+
+ def add_flags(self, ext):
+ # Ensure that PY_ARRAY_UNIQUE_SYMBOL is uniquely defined for
+ # each extension
+ array_api_name = 'MPL_' + ext.name.replace('.', '_') + '_ARRAY_API'
+
+ ext.define_macros.append(('PY_ARRAY_UNIQUE_SYMBOL', array_api_name))
+ ext.add_hook('include_dirs', self.include_dirs_hook)
+
+ ext.define_macros.append(('NPY_NO_DEPRECATED_API',
+ 'NPY_1_7_API_VERSION'))
+
+ # Allow NumPy's printf format specifiers in C++.
+ ext.define_macros.append(('__STDC_FORMAT_MACROS', 1))
+
+ def get_setup_requires(self):
+ return ['numpy>=1.7.1']
+
+ def get_install_requires(self):
+ return ['numpy>=1.7.1']
+
+
+class LibAgg(SetupPackage):
+ name = 'libagg'
+
+ def check(self):
+ self.__class__.found_external = True
+ try:
+ return self._check_for_pkg_config(
+ 'libagg', 'agg2/agg_basics.h', min_version='PATCH')
+ except CheckFailed as e:
+ self.__class__.found_external = False
+ return str(e) + ' Using local copy.'
+
+ def add_flags(self, ext, add_sources=True):
+ if self.found_external:
+ pkg_config.setup_extension(ext, 'libagg')
+ else:
+ ext.include_dirs.insert(0, 'extern/agg24-svn/include')
+ if add_sources:
+ agg_sources = [
+ 'agg_bezier_arc.cpp',
+ 'agg_curves.cpp',
+ 'agg_image_filters.cpp',
+ 'agg_trans_affine.cpp',
+ 'agg_vcgen_contour.cpp',
+ 'agg_vcgen_dash.cpp',
+ 'agg_vcgen_stroke.cpp',
+ 'agg_vpgen_segmentator.cpp'
+ ]
+ ext.sources.extend(
+ os.path.join('extern', 'agg24-svn', 'src', x) for x in agg_sources)
+
+
+class FreeType(SetupPackage):
+ name = "freetype"
+ pkg_names = {
+ "apt-get": "libfreetype6-dev",
+ "yum": "freetype-devel",
+ "dnf": "freetype-devel",
+ "brew": "freetype",
+ "port": "freetype",
+ "windows_url": "http://gnuwin32.sourceforge.net/packages/freetype.htm"
+ }
+
+ def check(self):
+ if options.get('local_freetype'):
+ return "Using local version for testing"
+
+ if sys.platform == 'win32':
+ try:
+ check_include_file(get_include_dirs(), 'ft2build.h', 'freetype')
+ except CheckFailed:
+ check_include_file(get_include_dirs(), os.path.join('freetype2', 'ft2build.h'), 'freetype')
+ return 'Using unknown version found on system.'
+
+ status, output = getstatusoutput("freetype-config --ftversion")
+ if status == 0:
+ version = output
+ else:
+ version = None
+
+ # Early versions of freetype grep badly inside freetype-config,
+ # so catch those cases. (tested with 2.5.3).
+ if version is None or 'No such file or directory\ngrep:' in version:
+ version = self.version_from_header()
+
+ # pkg_config returns the libtool version rather than the
+ # freetype version so we need to explicitly pass the version
+ # to _check_for_pkg_config
+ return self._check_for_pkg_config(
+ 'freetype2', 'ft2build.h',
+ min_version='2.3', version=version)
+
+ def version_from_header(self):
+ version = 'unknown'
+ ext = self.get_extension()
+ if ext is None:
+ return version
+ # Return the first version found in the include dirs.
+ for include_dir in ext.include_dirs:
+ header_fname = os.path.join(include_dir, 'freetype.h')
+ if os.path.exists(header_fname):
+ major, minor, patch = 0, 0, 0
+ with open(header_fname, 'r') as fh:
+ for line in fh:
+ if line.startswith('#define FREETYPE_'):
+ value = line.rsplit(' ', 1)[1].strip()
+ if 'MAJOR' in line:
+ major = value
+ elif 'MINOR' in line:
+ minor = value
+ else:
+ patch = value
+ return '.'.join([major, minor, patch])
+
+ def add_flags(self, ext):
+ if options.get('local_freetype'):
+ src_path = os.path.join(
+ 'build', 'freetype-{0}'.format(LOCAL_FREETYPE_VERSION))
+ # Statically link to the locally-built freetype.
+ # This is certainly broken on Windows.
+ ext.include_dirs.insert(0, os.path.join(src_path, 'include'))
+ if sys.platform == 'win32':
+ libfreetype = 'libfreetype.lib'
+ else:
+ libfreetype = 'libfreetype.a'
+ ext.extra_objects.insert(
+ 0, os.path.join(src_path, 'objs', '.libs', libfreetype))
+ ext.define_macros.append(('FREETYPE_BUILD_TYPE', 'local'))
+ else:
+ pkg_config.setup_extension(
+ ext, 'freetype2',
+ default_include_dirs=[
+ 'include/freetype2', 'freetype2',
+ 'lib/freetype2/include',
+ 'lib/freetype2/include/freetype2'],
+ default_library_dirs=[
+ 'freetype2/lib'],
+ default_libraries=['freetype', 'z'])
+ ext.define_macros.append(('FREETYPE_BUILD_TYPE', 'system'))
+
+ def do_custom_build(self):
+ # We're using a system freetype
+ if not options.get('local_freetype'):
+ return
+
+ src_path = os.path.join(
+ 'build', 'freetype-{0}'.format(LOCAL_FREETYPE_VERSION))
+
+ # We've already built freetype
+ if sys.platform == 'win32':
+ libfreetype = 'libfreetype.lib'
+ else:
+ libfreetype = 'libfreetype.a'
+
+ # bailing because it is already built
+ if os.path.isfile(os.path.join(
+ src_path, 'objs', '.libs', libfreetype)):
+ return
+
+ # do we need to download / load the source from cache?
+ if not os.path.exists(src_path):
+ if not os.path.exists('build'):
+ os.makedirs('build')
+
+ url_fmts = [
+ ('https://downloads.sourceforge.net/project/freetype'
+ '/freetype2/{version}/{tarball}'),
+ ('https://download.savannah.gnu.org/releases/freetype'
+ '/{tarball}')
+ ]
+ tarball = 'freetype-{0}.tar.gz'.format(LOCAL_FREETYPE_VERSION)
+
+ target_urls = [
+ url_fmt.format(version=LOCAL_FREETYPE_VERSION,
+ tarball=tarball)
+ for url_fmt in url_fmts]
+
+ for tarball_url in target_urls:
+ try:
+ tar_contents = download_or_cache(tarball_url,
+ LOCAL_FREETYPE_HASH)
+ break
+ except Exception:
+ pass
+ else:
+ raise IOError("Failed to download FreeType. Please download "
+ "one of {target_urls} and extract it into "
+ "{src_path} at the top-level of the source "
+ "repository".format(
+ target_urls=target_urls, src_path=src_path))
+
+ print("Extracting {}".format(tarball))
+ # just to be sure
+ tar_contents.seek(0)
+ with tarfile.open(tarball, mode="r:gz",
+ fileobj=tar_contents) as tgz:
+ tgz.extractall("build")
+
+ print("Building freetype in {}".format(src_path))
+ if sys.platform != 'win32':
+ # compilation on all other platforms than windows
+ cflags = 'CFLAGS="{0} -fPIC" '.format(os.environ.get('CFLAGS', ''))
+
+ subprocess.check_call(
+ [cflags + './configure --with-zlib=no --with-bzip2=no '
+ '--with-png=no --with-harfbuzz=no'], shell=True, cwd=src_path)
+ subprocess.check_call(
+ [cflags + 'make'], shell=True, cwd=src_path)
+ else:
+ # compilation on windows
+ FREETYPE_BUILD_CMD = """\
+call "%ProgramFiles%\\Microsoft SDKs\\Windows\\v7.0\\Bin\\SetEnv.Cmd" /Release /{xXX} /xp
+call "{vcvarsall}" {xXX}
+set MSBUILD=C:\\Windows\\Microsoft.NET\\Framework\\v4.0.30319\\MSBuild.exe
+rd /S /Q %FREETYPE%\\objs
+%MSBUILD% %FREETYPE%\\builds\\windows\\{vc20xx}\\freetype.sln /t:Clean;Build /p:Configuration="{config}";Platform={WinXX}
+echo Build completed, moving result"
+:: move to the "normal" path for the unix builds...
+mkdir %FREETYPE%\\objs\\.libs
+:: REMINDER: fix when changing the version
+copy %FREETYPE%\\objs\\{vc20xx}\\{xXX}\\freetype261.lib %FREETYPE%\\objs\\.libs\\libfreetype.lib
+if errorlevel 1 (
+ rem This is a py27 version, which has a different location for the lib file :-/
+ copy %FREETYPE%\\objs\\win32\\{vc20xx}\\freetype261.lib %FREETYPE%\\objs\\.libs\\libfreetype.lib
+)
+"""
+ from setup_external_compile import fixproj, prepare_build_cmd, VS2010, X64
+ # Note: freetype has no build profile for 2014, so we don't bother...
+ vc = 'vc2010' if VS2010 else 'vc2008'
+ WinXX = 'x64' if X64 else 'Win32'
+ # This is only false for py2.7, even on py3.5...
+ if not VS2010:
+ fixproj(os.path.join(src_path, 'builds', 'windows', vc, 'freetype.sln'), WinXX)
+ fixproj(os.path.join(src_path, 'builds', 'windows', vc, 'freetype.vcproj'), WinXX)
+
+ cmdfile = os.path.join("build", 'build_freetype.cmd')
+ with open(cmdfile, 'w') as cmd:
+ cmd.write(prepare_build_cmd(FREETYPE_BUILD_CMD, vc20xx=vc, WinXX=WinXX,
+ config='Release' if VS2010 else 'LIB Release'))
+
+ os.environ['FREETYPE'] = src_path
+ subprocess.check_call([cmdfile], shell=True)
+
+
+class FT2Font(SetupPackage):
+ name = 'ft2font'
+
+ def get_extension(self):
+ sources = [
+ 'src/ft2font.cpp',
+ 'src/ft2font_wrapper.cpp',
+ 'src/mplutils.cpp'
+ ]
+ ext = make_extension('matplotlib.ft2font', sources)
+ FreeType().add_flags(ext)
+ Numpy().add_flags(ext)
+ return ext
+
+
+class Png(SetupPackage):
+ name = "png"
+ pkg_names = {
+ "apt-get": "libpng12-dev",
+ "yum": "libpng-devel",
+ "dnf": "libpng-devel",
+ "brew": "libpng",
+ "port": "libpng",
+ "windows_url": "http://gnuwin32.sourceforge.net/packages/libpng.htm"
+ }
+
+ def check(self):
+ if sys.platform == 'win32':
+ check_include_file(get_include_dirs(), 'png.h', 'png')
+ return 'Using unknown version found on system.'
+
+ status, output = getstatusoutput("libpng-config --version")
+ if status == 0:
+ version = output
+ else:
+ version = None
+
+ try:
+ return self._check_for_pkg_config(
+ 'libpng', 'png.h',
+ min_version='1.2', version=version)
+ except CheckFailed as e:
+ if has_include_file(get_include_dirs(), 'png.h'):
+ return str(e) + ' Using unknown version found on system.'
+ raise
+
+ def get_extension(self):
+ sources = [
+ 'src/_png.cpp',
+ 'src/mplutils.cpp'
+ ]
+ ext = make_extension('matplotlib._png', sources)
+ pkg_config.setup_extension(
+ ext, 'libpng', default_libraries=['png', 'z'],
+ alt_exec='libpng-config --ldflags')
+ Numpy().add_flags(ext)
+ return ext
+
+
+class Qhull(SetupPackage):
+ name = "qhull"
+
+ def check(self):
+ self.__class__.found_external = True
+ try:
+ return self._check_for_pkg_config(
+ 'libqhull', 'libqhull/qhull_a.h', min_version='2015.2')
+ except CheckFailed as e:
+ self.__class__.found_pkgconfig = False
+ self.__class__.found_external = False
+ return str(e) + ' Using local copy.'
+
+ def add_flags(self, ext):
+ if self.found_external:
+ pkg_config.setup_extension(ext, 'qhull',
+ default_libraries=['qhull'])
+ else:
+ ext.include_dirs.insert(0, 'extern')
+ ext.sources.extend(sorted(glob.glob('extern/libqhull/*.c')))
+ if sysconfig.get_config_var('LIBM') == '-lm':
+ ext.libraries.extend('m')
+
+
+class TTConv(SetupPackage):
+ name = "ttconv"
+
+ def get_extension(self):
+ sources = [
+ 'src/_ttconv.cpp',
+ 'extern/ttconv/pprdrv_tt.cpp',
+ 'extern/ttconv/pprdrv_tt2.cpp',
+ 'extern/ttconv/ttutil.cpp'
+ ]
+ ext = make_extension('matplotlib.ttconv', sources)
+ Numpy().add_flags(ext)
+ ext.include_dirs.insert(0, 'extern')
+ return ext
+
+
+class Path(SetupPackage):
+ name = "path"
+
+ def get_extension(self):
+ sources = [
+ 'src/py_converters.cpp',
+ 'src/_path_wrapper.cpp'
+ ]
+
+ ext = make_extension('matplotlib._path', sources)
+ Numpy().add_flags(ext)
+ LibAgg().add_flags(ext)
+ return ext
+
+
+class Image(SetupPackage):
+ name = "image"
+
+ def get_extension(self):
+ sources = [
+ 'src/_image.cpp',
+ 'src/mplutils.cpp',
+ 'src/_image_wrapper.cpp',
+ 'src/py_converters.cpp'
+ ]
+ ext = make_extension('matplotlib._image', sources)
+ Numpy().add_flags(ext)
+ LibAgg().add_flags(ext)
+
+ return ext
+
+
+class Contour(SetupPackage):
+ name = "contour"
+
+ def get_extension(self):
+ sources = [
+ "src/_contour.cpp",
+ "src/_contour_wrapper.cpp",
+ ]
+ ext = make_extension('matplotlib._contour', sources)
+ Numpy().add_flags(ext)
+ return ext
+
+
+class QhullWrap(SetupPackage):
+ name = "qhull_wrap"
+
+ def get_extension(self):
+ sources = ['src/qhull_wrap.c']
+ ext = make_extension('matplotlib._qhull', sources,
+ define_macros=[('MPL_DEVNULL', os.devnull)])
+ Numpy().add_flags(ext)
+ Qhull().add_flags(ext)
+ return ext
+
+
+class Tri(SetupPackage):
+ name = "tri"
+
+ def get_extension(self):
+ sources = [
+ "lib/matplotlib/tri/_tri.cpp",
+ "lib/matplotlib/tri/_tri_wrapper.cpp",
+ "src/mplutils.cpp"
+ ]
+ ext = make_extension('matplotlib._tri', sources)
+ Numpy().add_flags(ext)
+ return ext
+
+
+class InstallRequires(SetupPackage):
+ name = "install_requires"
+
+ def check(self):
+ not_available = []
+ wrong_version = []
+ inst_req = self.get_install_requires()
+ for pack_inf in inst_req:
+ pack_inf_disp = pack_inf.split('>=')
+ if 'dateutil' in pack_inf_disp[0]:
+ pack_inf_disp[0] = 'dateutil'
+ pack_name = pack_inf_disp[0]
+ try:
+ import_module(pack_name)
+ if pack_name != pack_inf_disp[-1]:
+ # This means that we have to check for the version
+ pack_ver = sys.modules[pack_name].__version__
+ pack_ver = [int(ele) for ele in pack_ver.split('.')]
+ ver_cond = pack_inf_disp[1].split(',!=')
+ # Check for minimum version
+ if pack_ver < [int(ele) for ele in ver_cond[0].split('.')]:
+ if len(ver_cond[1:]) > 0:
+ wrong_version.append(pack_name
+ +" is not at least at version "
+ +ver_cond[0]+os.linesep
+ +"Please upgrade!"+os.linesep
+ +"WARNING: Version(s) "
+ +", ".join(ver_cond[1:])
+ +" have issues and must be "
+ +"avoided.")
+ else:
+ wrong_version.append(pack_name
+ +" is not at least at version "
+ +ver_cond[0]+os.linesep
+ +"Please upgrade!")
+ continue
+ # Check for forbidden versions if any
+ for ver in ver_cond[1:]:
+ if pack_ver == [int(ele) for ele in ver.split('.')]:
+ wrong_version.append(pack_name+" is at version "
+ +ver+" which is not allowed."+os.linesep
+ +"Please use a version newer than "+ver_cond[0]
+ +" but different from "+", ".join(ver_cond[1:]))
+ break
+ except ImportError:
+ not_available.append(pack_name+" could not be found")
+ if not_available or wrong_version:
+ sp_mult = min(1, len(wrong_version))
+ req_fail_msg = "ERROR: At least one third-party python package " + \
+ "is missing or has the wrong version:" + os.linesep
+ req_fail_msg += (os.linesep.join(not_available) +
+ os.linesep*(2*sp_mult)) * min(1, len(not_available))
+ req_fail_msg += (os.linesep*2).join(wrong_version)
+ print_message(req_fail_msg)
+ raise CheckFailed("missing or faulty third-party python packages")
+ return "all third-party python packages are present"
+
+ def get_install_requires(self):
+ install_requires = [
+ "cycler>=0.10",
+ "pyparsing>=2.0.1,!=2.0.4,!=2.1.2,!=2.1.6",
+ "python-dateutil>=2.1",
+ "pytz",
+ "six>=1.10",
+ "kiwisolver>=1.0.1",
+ ]
+ if sys.version_info < (3,):
+ install_requires += ["backports.functools_lru_cache"]
+ if sys.version_info < (3,) and os.name == "posix":
+ install_requires += ["subprocess32"]
+ return install_requires
+
+
+class BackendAgg(OptionalBackendPackage):
+ name = "agg"
+ force = True
+
+ def get_extension(self):
+ sources = [
+ "src/mplutils.cpp",
+ "src/py_converters.cpp",
+ "src/_backend_agg.cpp",
+ "src/_backend_agg_wrapper.cpp"
+ ]
+ ext = make_extension('matplotlib.backends._backend_agg', sources)
+ Numpy().add_flags(ext)
+ LibAgg().add_flags(ext)
+ FreeType().add_flags(ext)
+ return ext
+
+
+class BackendTkAgg(OptionalBackendPackage):
+ name = "tkagg"
+ force = True
+
+ def check(self):
+ return "installing; run-time loading from Python Tcl / Tk"
+
+ def runtime_check(self):
+ """ Checks whether TkAgg runtime dependencies are met
+ """
+ pkg_name = 'tkinter' if PY3min else 'Tkinter'
+ try:
+ import_module(pkg_name)
+ except ImportError:
+ return False
+ return True
+
+ def get_extension(self):
+ sources = [
+ 'src/_tkagg.cpp'
+ ]
+
+ ext = make_extension('matplotlib.backends._tkagg', sources)
+ self.add_flags(ext)
+ LibAgg().add_flags(ext, add_sources=False)
+ return ext
+
+ def add_flags(self, ext):
+ ext.include_dirs.insert(0, 'src')
+ if sys.platform == 'win32':
+ # PSAPI library needed for finding Tcl / Tk at run time
+ ext.libraries.extend(['psapi'])
+ elif sys.platform.startswith('linux'):
+ ext.libraries.extend(['dl'])
+
+
+class BackendGtk(OptionalBackendPackage):
+ name = "gtk"
+
+ def check_requirements(self):
+ try:
+ import gtk
+ except ImportError:
+ raise CheckFailed("Requires pygtk")
+ except RuntimeError:
+ raise CheckFailed('pygtk present, but import failed.')
+ else:
+ version = (2, 2, 0)
+ if gtk.pygtk_version < version:
+ raise CheckFailed(
+ "Requires pygtk %d.%d.%d or later. "
+ "Found %d.%d.%d" % (version + gtk.pygtk_version))
+
+ ext = self.get_extension()
+ self.add_flags(ext)
+ check_include_file(ext.include_dirs,
+ os.path.join("gtk", "gtk.h"),
+ 'gtk')
+ check_include_file(ext.include_dirs,
+ os.path.join("pygtk", "pygtk.h"),
+ 'pygtk')
+
+ return 'Gtk: %s pygtk: %s' % (
+ ".".join(str(x) for x in gtk.gtk_version),
+ ".".join(str(x) for x in gtk.pygtk_version))
+
+ def get_package_data(self):
+ return {'matplotlib': ['mpl-data/*.glade']}
+
+ def get_extension(self):
+ sources = [
+ 'src/_backend_gdk.c'
+ ]
+ ext = make_extension('matplotlib.backends._backend_gdk', sources)
+ self.add_flags(ext)
+ Numpy().add_flags(ext)
+ return ext
+
+ def add_flags(self, ext):
+ if sys.platform == 'win32':
+ def getoutput(s):
+ ret = os.popen(s).read().strip()
+ return ret
+
+ if 'PKG_CONFIG_PATH' not in os.environ:
+ # If Gtk+ is installed, pkg-config is required to be installed
+ os.environ['PKG_CONFIG_PATH'] = 'C:\\GTK\\lib\\pkgconfig'
+
+ # popen broken on my win32 platform so I can't use pkgconfig
+ ext.library_dirs.extend(
+ ['C:/GTK/bin', 'C:/GTK/lib'])
+
+ ext.include_dirs.extend(
+ ['win32_static/include/pygtk-2.0',
+ 'C:/GTK/include',
+ 'C:/GTK/include/gobject',
+ 'C:/GTK/include/gext',
+ 'C:/GTK/include/glib',
+ 'C:/GTK/include/pango',
+ 'C:/GTK/include/atk',
+ 'C:/GTK/include/X11',
+ 'C:/GTK/include/cairo',
+ 'C:/GTK/include/gdk',
+ 'C:/GTK/include/gdk-pixbuf',
+ 'C:/GTK/include/gtk',
+ ])
+
+ pygtkIncludes = getoutput(
+ 'pkg-config --cflags-only-I pygtk-2.0').split()
+ gtkIncludes = getoutput(
+ 'pkg-config --cflags-only-I gtk+-2.0').split()
+ includes = pygtkIncludes + gtkIncludes
+ ext.include_dirs.extend([include[2:] for include in includes])
+
+ pygtkLinker = getoutput('pkg-config --libs pygtk-2.0').split()
+ gtkLinker = getoutput('pkg-config --libs gtk+-2.0').split()
+ linkerFlags = pygtkLinker + gtkLinker
+
+ ext.libraries.extend(
+ [flag[2:] for flag in linkerFlags if flag.startswith('-l')])
+
+ ext.library_dirs.extend(
+ [flag[2:] for flag in linkerFlags if flag.startswith('-L')])
+
+ ext.extra_link_args.extend(
+ [flag for flag in linkerFlags if not
+ (flag.startswith('-l') or flag.startswith('-L'))])
+
+ # visual studio doesn't need the math library
+ if (sys.platform == 'win32' and
+ win32_compiler == 'msvc' and
+ 'm' in ext.libraries):
+ ext.libraries.remove('m')
+
+ elif sys.platform != 'win32':
+ pkg_config.setup_extension(ext, 'pygtk-2.0')
+ pkg_config.setup_extension(ext, 'gtk+-2.0')
+
+
+class BackendGtkAgg(BackendGtk):
+ name = "gtkagg"
+
+ def get_package_data(self):
+ return {'matplotlib': ['mpl-data/*.glade']}
+
+ def get_extension(self):
+ sources = [
+ 'src/py_converters.cpp',
+ 'src/_gtkagg.cpp',
+ 'src/mplutils.cpp'
+ ]
+ ext = make_extension('matplotlib.backends._gtkagg', sources)
+ self.add_flags(ext)
+ LibAgg().add_flags(ext)
+ Numpy().add_flags(ext)
+ return ext
+
+
+def backend_gtk3agg_internal_check(x):
+ try:
+ import gi
+ except ImportError:
+ return (False, "Requires pygobject to be installed.")
+
+ try:
+ gi.require_version("Gtk", "3.0")
+ except ValueError:
+ return (False, "Requires gtk3 development files to be installed.")
+ except AttributeError:
+ return (False, "pygobject version too old.")
+
+ try:
+ from gi.repository import Gtk, Gdk, GObject
+ except (ImportError, RuntimeError):
+ return (False, "Requires pygobject to be installed.")
+
+ return (True, "version %s.%s.%s" % (
+ Gtk.get_major_version(),
+ Gtk.get_micro_version(),
+ Gtk.get_minor_version()))
+
+
+class BackendGtk3Agg(OptionalBackendPackage):
+ name = "gtk3agg"
+
+ def check_requirements(self):
+ if 'TRAVIS' in os.environ:
+ raise CheckFailed("Can't build with Travis")
+
+ # This check needs to be performed out-of-process, because
+ # importing gi and then importing regular old pygtk afterward
+ # segfaults the interpreter.
+ try:
+ p = multiprocessing.Pool()
+ except:
+ return "unknown (can not use multiprocessing to determine)"
+ try:
+ res = p.map_async(backend_gtk3agg_internal_check, [0])
+ success, msg = res.get(timeout=10)[0]
+ except multiprocessing.TimeoutError:
+ p.terminate()
+ # No result returned. Probably hanging, terminate the process.
+ success = False
+ raise CheckFailed("Check timed out")
+ except:
+ p.close()
+ # Some other error.
+ success = False
+ msg = "Could not determine"
+ raise
+ else:
+ p.close()
+ finally:
+ p.join()
+
+ if success:
+ return msg
+ else:
+ raise CheckFailed(msg)
+
+ def get_package_data(self):
+ return {'matplotlib': ['mpl-data/*.glade']}
+
+
+def backend_gtk3cairo_internal_check(x):
+ try:
+ import cairocffi
+ except ImportError:
+ try:
+ import cairo
+ except ImportError:
+ return (False, "Requires cairocffi or pycairo to be installed.")
+
+ try:
+ import gi
+ except ImportError:
+ return (False, "Requires pygobject to be installed.")
+
+ try:
+ gi.require_version("Gtk", "3.0")
+ except ValueError:
+ return (False, "Requires gtk3 development files to be installed.")
+ except AttributeError:
+ return (False, "pygobject version too old.")
+
+ try:
+ from gi.repository import Gtk, Gdk, GObject
+ except (RuntimeError, ImportError):
+ return (False, "Requires pygobject to be installed.")
+
+ return (True, "version %s.%s.%s" % (
+ Gtk.get_major_version(),
+ Gtk.get_micro_version(),
+ Gtk.get_minor_version()))
+
+
+class BackendGtk3Cairo(OptionalBackendPackage):
+ name = "gtk3cairo"
+
+ def check_requirements(self):
+ if 'TRAVIS' in os.environ:
+ raise CheckFailed("Can't build with Travis")
+
+ # This check needs to be performed out-of-process, because
+ # importing gi and then importing regular old pygtk afterward
+ # segfaults the interpreter.
+ try:
+ p = multiprocessing.Pool()
+ except:
+ return "unknown (can not use multiprocessing to determine)"
+ try:
+ res = p.map_async(backend_gtk3cairo_internal_check, [0])
+ success, msg = res.get(timeout=10)[0]
+ except multiprocessing.TimeoutError:
+ p.terminate()
+ # No result returned. Probably hanging, terminate the process.
+ success = False
+ raise CheckFailed("Check timed out")
+ except:
+ p.close()
+ success = False
+ raise
+ else:
+ p.close()
+ finally:
+ p.join()
+
+ if success:
+ return msg
+ else:
+ raise CheckFailed(msg)
+
+ def get_package_data(self):
+ return {'matplotlib': ['mpl-data/*.glade']}
+
+
+class BackendWxAgg(OptionalBackendPackage):
+ name = "wxagg"
+
+ def check_requirements(self):
+ wxversioninstalled = True
+ try:
+ import wxversion
+ except ImportError:
+ wxversioninstalled = False
+
+ if wxversioninstalled:
+ try:
+ _wx_ensure_failed = wxversion.AlreadyImportedError
+ except AttributeError:
+ _wx_ensure_failed = wxversion.VersionError
+
+ try:
+ wxversion.ensureMinimal('2.9')
+ except _wx_ensure_failed:
+ pass
+
+ try:
+ import wx
+ backend_version = wx.VERSION_STRING
+ except ImportError:
+ raise CheckFailed("requires wxPython")
+
+ if not is_min_version(backend_version, "2.9"):
+ raise CheckFailed(
+ "Requires wxPython 2.9, found %s" % backend_version)
+
+ return "version %s" % backend_version
+
+
+class BackendMacOSX(OptionalBackendPackage):
+ name = 'macosx'
+
+ def check_requirements(self):
+ if sys.platform != 'darwin':
+ raise CheckFailed("Mac OS-X only")
+
+ return 'darwin'
+
+ def get_extension(self):
+ sources = [
+ 'src/_macosx.m'
+ ]
+
+ ext = make_extension('matplotlib.backends._macosx', sources)
+ ext.extra_link_args.extend(['-framework', 'Cocoa'])
+ return ext
+
+
+class Windowing(OptionalBackendPackage):
+ """
+ Builds the windowing extension.
+ """
+ name = "windowing"
+
+ def check_requirements(self):
+ if sys.platform != 'win32':
+ raise CheckFailed("Microsoft Windows only")
+ config = self.get_config()
+ if config is False:
+ raise CheckFailed("skipping due to configuration")
+ return ""
+
+ def get_extension(self):
+ sources = [
+ "src/_windowing.cpp"
+ ]
+ ext = make_extension('matplotlib._windowing', sources)
+ ext.include_dirs.extend(['C:/include'])
+ ext.libraries.extend(['user32'])
+ ext.library_dirs.extend(['C:/lib'])
+ ext.extra_link_args.append("-mwindows")
+ return ext
+
+
+class BackendQtBase(OptionalBackendPackage):
+
+ def convert_qt_version(self, version):
+ version = '%x' % version
+ temp = []
+ while len(version) > 0:
+ version, chunk = version[:-2], version[-2:]
+ temp.insert(0, str(int(chunk, 16)))
+ return '.'.join(temp)
+
+ def check_requirements(self):
+ '''
+ If PyQt4/PyQt5 is already imported, importing PyQt5/PyQt4 will fail
+ so we need to test in a subprocess (as for Gtk3).
+ '''
+ try:
+ p = multiprocessing.Pool()
+
+ except:
+ # Can't do multiprocessing, fall back to normal approach
+ # (this will fail if importing both PyQt4 and PyQt5).
+ try:
+ # Try in-process
+ msg = self.callback(self)
+ except RuntimeError:
+ raise CheckFailed(
+ "Could not import: are PyQt4 & PyQt5 both installed?")
+
+ else:
+ # Multiprocessing OK
+ try:
+ res = p.map_async(self.callback, [self])
+ msg = res.get(timeout=10)[0]
+ except multiprocessing.TimeoutError:
+ p.terminate()
+ # No result returned. Probably hanging, terminate the process.
+ raise CheckFailed("Check timed out")
+ except:
+ # Some other error.
+ p.close()
+ raise
+ else:
+ # Clean exit
+ p.close()
+ finally:
+ # Tidy up multiprocessing
+ p.join()
+
+ return msg
+
+
+def backend_pyside_internal_check(self):
+ try:
+ from PySide import __version__
+ from PySide import QtCore
+ except ImportError:
+ raise CheckFailed("PySide not found")
+ else:
+ return ("Qt: %s, PySide: %s" %
+ (QtCore.__version__, __version__))
+
+
+def backend_pyqt4_internal_check(self):
+ try:
+ from PyQt4 import QtCore
+ except ImportError:
+ raise CheckFailed("PyQt4 not found")
+
+ try:
+ qt_version = QtCore.QT_VERSION
+ pyqt_version_str = QtCore.PYQT_VERSION_STR
+ except AttributeError:
+ raise CheckFailed('PyQt4 not correctly imported')
+ else:
+ return ("Qt: %s, PyQt: %s" % (self.convert_qt_version(qt_version), pyqt_version_str))
+
+
+def backend_qt4_internal_check(self):
+ successes = []
+ failures = []
+ try:
+ successes.append(backend_pyside_internal_check(self))
+ except CheckFailed as e:
+ failures.append(str(e))
+
+ try:
+ successes.append(backend_pyqt4_internal_check(self))
+ except CheckFailed as e:
+ failures.append(str(e))
+
+ if len(successes) == 0:
+ raise CheckFailed('; '.join(failures))
+ return '; '.join(successes + failures)
+
+
+class BackendQt4(BackendQtBase):
+ name = "qt4agg"
+
+ def __init__(self, *args, **kwargs):
+ BackendQtBase.__init__(self, *args, **kwargs)
+ self.callback = backend_qt4_internal_check
+
+def backend_pyside2_internal_check(self):
+ try:
+ from PySide2 import __version__
+ from PySide2 import QtCore
+ except ImportError:
+ raise CheckFailed("PySide2 not found")
+ else:
+ return ("Qt: %s, PySide2: %s" %
+ (QtCore.__version__, __version__))
+
+def backend_pyqt5_internal_check(self):
+ try:
+ from PyQt5 import QtCore
+ except ImportError:
+ raise CheckFailed("PyQt5 not found")
+
+ try:
+ qt_version = QtCore.QT_VERSION
+ pyqt_version_str = QtCore.PYQT_VERSION_STR
+ except AttributeError:
+ raise CheckFailed('PyQt5 not correctly imported')
+ else:
+ return ("Qt: %s, PyQt: %s" % (self.convert_qt_version(qt_version), pyqt_version_str))
+
+def backend_qt5_internal_check(self):
+ successes = []
+ failures = []
+ try:
+ successes.append(backend_pyside2_internal_check(self))
+ except CheckFailed as e:
+ failures.append(str(e))
+
+ try:
+ successes.append(backend_pyqt5_internal_check(self))
+ except CheckFailed as e:
+ failures.append(str(e))
+
+ if len(successes) == 0:
+ raise CheckFailed('; '.join(failures))
+ return '; '.join(successes + failures)
+
+class BackendQt5(BackendQtBase):
+ name = "qt5agg"
+
+ def __init__(self, *args, **kwargs):
+ BackendQtBase.__init__(self, *args, **kwargs)
+ self.callback = backend_qt5_internal_check
+
+
+class BackendCairo(OptionalBackendPackage):
+ name = "cairo"
+
+ def check_requirements(self):
+ try:
+ import cairocffi
+ except ImportError:
+ try:
+ import cairo
+ except ImportError:
+ raise CheckFailed("cairocffi or pycairo not found")
+ else:
+ return "pycairo version %s" % cairo.version
+ else:
+ return "cairocffi version %s" % cairocffi.version
+
+
+class DviPng(SetupPackage):
+ name = "dvipng"
+ optional = True
+
+ def check(self):
+ try:
+ output = check_output('dvipng -version', shell=True,
+ stderr=subprocess.STDOUT)
+ return "version %s" % output.splitlines()[1].decode().split()[-1]
+ except (IndexError, ValueError, subprocess.CalledProcessError):
+ raise CheckFailed()
+
+
+class Ghostscript(SetupPackage):
+ name = "ghostscript"
+ optional = True
+
+ def check(self):
+ if sys.platform == 'win32':
+ # mgs is the name in miktex
+ gs_execs = ['gswin32c', 'gswin64c', 'mgs', 'gs']
+ else:
+ gs_execs = ['gs']
+ for gs_exec in gs_execs:
+ try:
+ command = gs_exec + ' --version'
+ output = check_output(command, shell=True,
+ stderr=subprocess.STDOUT)
+ return "version %s" % output.decode()[:-1]
+ except (IndexError, ValueError, subprocess.CalledProcessError):
+ pass
+
+ raise CheckFailed()
+
+
+class LaTeX(SetupPackage):
+ name = "latex"
+ optional = True
+
+ def check(self):
+ try:
+ output = check_output('latex -version', shell=True,
+ stderr=subprocess.STDOUT)
+ line = output.splitlines()[0].decode()
+ pattern = r'(3\.1\d+)|(MiKTeX \d+.\d+)'
+ match = re.search(pattern, line)
+ return "version %s" % match.group(0)
+ except (IndexError, ValueError, AttributeError, subprocess.CalledProcessError):
+ raise CheckFailed()
+
+
+class PdfToPs(SetupPackage):
+ name = "pdftops"
+ optional = True
+
+ def check(self):
+ try:
+ output = check_output('pdftops -v', shell=True,
+ stderr=subprocess.STDOUT)
+ for line in output.splitlines():
+ line = line.decode()
+ if 'version' in line:
+ return "version %s" % line.split()[2]
+ except (IndexError, ValueError, subprocess.CalledProcessError):
+ pass
+
+ raise CheckFailed()
+
+
+class OptionalPackageData(OptionalPackage):
+ config_category = "package_data"
+
+
+class Dlls(OptionalPackageData):
+ """
+ On Windows, this packages any DLL files that can be found in the
+ lib/matplotlib/* directories.
+ """
+ name = "dlls"
+
+ def check_requirements(self):
+ if sys.platform != 'win32':
+ raise CheckFailed("Microsoft Windows only")
+
+ def get_package_data(self):
+ return {'': ['*.dll']}
+
+ @classmethod
+ def get_config(cls):
+ """
+ Look at `setup.cfg` and return one of ["auto", True, False] indicating
+ if the package is at default state ("auto"), forced by the user (True)
+ or opted-out (False).
+ """
+ try:
+ return config.getboolean(cls.config_category, cls.name)
+ except:
+ return False # <-- default
diff --git a/libraries/python2-matplotlib/slack-desc b/libraries/python2-matplotlib/slack-desc
new file mode 100644
index 0000000000..c59df0596a
--- /dev/null
+++ b/libraries/python2-matplotlib/slack-desc
@@ -0,0 +1,19 @@
+# HOW TO EDIT THIS FILE:
+# The "handy ruler" below makes it easier to edit a package description.
+# Line up the first '|' above the ':' following the base package name, and
+# the '|' on the right side marks the last column you can put a character in.
+# You must make exactly 11 lines for the formatting to be correct. It's also
+# customary to leave one space after the ':' except on otherwise blank lines.
+
+ |-----handy-ruler------------------------------------------------------|
+python2-matplotlib: python2-matplotlib (a Python 2D plotting library)
+python2-matplotlib:
+python2-matplotlib: Matplotlib is a plotting library for Python which uses
+python2-matplotlib: syntax similar to MATLAB. Matplotlib produces publication
+python2-matplotlib: quality figures in a variety of hardcopy formats and
+python2-matplotlib: interactive environments across platforms.
+python2-matplotlib:
+python2-matplotlib: Homepage: http://matplotlib.sourceforge.net/
+python2-matplotlib:
+python2-matplotlib: Version 2.2.5 is the last available for python2.
+python2-matplotlib: