#!/usr/bin/env python """Test script to check for required functionality. Execute this code at the command line by typing: python swc-installation-test-2.py Run the script and follow the instructions it prints at the end. This script requires at least Python 2.6. You can check the version of Python that you have installed with 'swc-installation-test-1.py'. By default, this script will test for all the dependencies your instructor thinks you need. If you want to test for a different set of packages, you can list them on the command line. For example: python swc-installation-test-2.py git virtual-editor This is useful if the original test told you to install a more recent version of a particular dependency, and you just want to re-test that dependency. """ # Some details about the implementation: # The dependencies are divided into a hierarchy of classes rooted on # Dependency class. You can refer to the code to see which package # comes under which type of dependency. # The CHECKER dictionary stores information about all the dependencies # and CHECKS stores list of the dependencies which are to be checked in # the current workshop. # In the "__name__ == '__main__'" block, we launch all the checks with # check() function, which prints information about the tests as they run # and details about the failures after the tests complete. In case of # failure, the functions print_system_info() and print_suggestions() # are called after this, where the former prints information about the # user's system for debugging purposes while the latter prints some # suggestions to follow. from __future__ import print_function # for Python 2.6 compatibility import distutils.ccompiler as _distutils_ccompiler import fnmatch as _fnmatch try: # Python 2.7 and 3.x import importlib as _importlib except ImportError: # Python 2.6 and earlier class _Importlib (object): """Minimal workarounds for functions we need """ @staticmethod def import_module(name): module = __import__(name) for n in name.split('.')[1:]: module = getattr(module, n) return module _importlib = _Importlib() import logging as _logging import os as _os import platform as _platform import re as _re import shlex as _shlex import subprocess as _subprocess import sys as _sys try: # Python 3.x import urllib.parse as _urllib_parse except ImportError: # Python 2.x import urllib as _urllib_parse # for quote() import xml.etree.ElementTree as _element_tree if not hasattr(_shlex, 'quote'): # Python versions older than 3.3 # Use the undocumented pipes.quote() import pipes as _pipes _shlex.quote = _pipes.quote __version__ = '0.1' # Comment out any entries you don't need CHECKS = [ # Shell 'virtual-shell', # Editors 'virtual-editor', # Browsers 'virtual-browser', # Version control 'git', 'hg', # Command line tool #'mercurial', # Python package 'EasyMercurial', # Build tools and packaging 'make', 'virtual-pypi-installer', 'setuptools', #'xcode', # Testing 'nosetests', # Command line tool 'nose', # Python package 'py.test', # Command line tool 'pytest', # Python package # SQL 'sqlite3', # Command line tool 'sqlite3-python', # Python package # Python 'python', 'ipython', # Command line tool 'IPython', # Python package 'argparse', # Useful for utility scripts 'numpy', 'scipy', 'matplotlib', 'pandas', #'sympy', #'Cython', #'networkx', #'mayavi.mlab', ] CHECKER = {} _ROOT_PATH = _os.sep if _platform.system() == 'win32': _ROOT_PATH = 'c:\\' class InvalidCheck (KeyError): def __init__(self, check): super(InvalidCheck, self).__init__(check) self.check = check def __str__(self): return self.check class DependencyError (Exception): _default_url = 'http://software-carpentry.org/setup/' _setup_urls = { # (system, version, package) glob pairs ('*', '*', 'Cython'): 'http://docs.cython.org/src/quickstart/install.html', ('Linux', '*', 'EasyMercurial'): 'http://easyhg.org/download.html#download-linux', ('Darwin', '*', 'EasyMercurial'): 'http://easyhg.org/download.html#download-mac', ('Windows', '*', 'EasyMercurial'): 'http://easyhg.org/download.html#download-windows', ('*', '*', 'EasyMercurial'): 'http://easyhg.org/download.html', ('*', '*', 'argparse'): 'https://pypi.python.org/pypi/argparse#installation', ('*', '*', 'ash'): 'http://www.in-ulm.de/~mascheck/various/ash/', ('*', '*', 'bash'): 'http://www.gnu.org/software/bash/manual/html_node/Basic-Installation.html#Basic-Installation', ('Linux', '*', 'chromium'): 'http://code.google.com/p/chromium/wiki/LinuxBuildInstructions', ('Darwin', '*', 'chromium'): 'http://code.google.com/p/chromium/wiki/MacBuildInstructions', ('Windows', '*', 'chromium'): 'http://www.chromium.org/developers/how-tos/build-instructions-windows', ('*', '*', 'chromium'): 'http://www.chromium.org/developers/how-tos', ('Windows', '*', 'emacs'): 'http://www.gnu.org/software/emacs/windows/Installing-Emacs.html', ('*', '*', 'emacs'): 'http://www.gnu.org/software/emacs/#Obtaining', ('*', '*', 'firefox'): 'http://www.mozilla.org/en-US/firefox/new/', ('Linux', '*', 'gedit'): 'http://www.linuxfromscratch.org/blfs/view/svn/gnome/gedit.html', ('*', '*', 'git'): 'http://git-scm.com/downloads', ('*', '*', 'google-chrome'): 'https://www.google.com/intl/en/chrome/browser/', ('*', '*', 'hg'): 'http://mercurial.selenic.com/', ('*', '*', 'mercurial'): 'http://mercurial.selenic.com/', ('*', '*', 'IPython'): 'http://ipython.org/install.html', ('*', '*', 'ipython'): 'http://ipython.org/install.html', ('*', '*', 'jinja'): 'http://jinja.pocoo.org/docs/intro/#installation', ('*', '*', 'kate'): 'http://kate-editor.org/get-it/', ('*', '*', 'make'): 'http://www.gnu.org/software/make/', ('Darwin', '*', 'matplotlib'): 'http://matplotlib.org/users/installing.html#building-on-osx', ('Windows', '*', 'matplotlib'): 'http://matplotlib.org/users/installing.html#installing-on-windows', ('*', '*', 'matplotlib'): 'http://matplotlib.org/users/installing.html#installing', ('*', '*', 'mayavi.mlab'): 'http://docs.enthought.com/mayavi/mayavi/installation.html', ('*', '*', 'nano'): 'http://www.nano-editor.org/dist/latest/faq.html#3', ('*', '*', 'networkx'): 'http://networkx.github.com/documentation/latest/install.html#installing', ('*', '*', 'nose'): 'https://nose.readthedocs.org/en/latest/#installation-and-quick-start', ('*', '*', 'nosetests'): 'https://nose.readthedocs.org/en/latest/#installation-and-quick-start', ('*', '*', 'notepad++'): 'http://notepad-plus-plus.org/download/v6.3.html', ('*', '*', 'numpy'): 'http://docs.scipy.org/doc/numpy/user/install.html', ('*', '*', 'pandas'): 'http://pandas.pydata.org/pandas-docs/stable/install.html', ('*', '*', 'pip'): 'http://www.pip-installer.org/en/latest/installing.html', ('*', '*', 'pytest'): 'http://pytest.org/latest/getting-started.html', ('*', '*', 'python'): 'http://www.python.org/download/releases/2.7.3/#download', ('*', '*', 'pyzmq'): 'https://github.com/zeromq/pyzmq/wiki/Building-and-Installing-PyZMQ', ('*', '*', 'py.test'): 'http://pytest.org/latest/getting-started.html', ('Linux', '*', 'scipy'): 'http://www.scipy.org/Installing_SciPy/Linux', ('Darwin', '*', 'scipy'): 'http://www.scipy.org/Installing_SciPy/Mac_OS_X', ('Windows', '*', 'scipy'): 'http://www.scipy.org/Installing_SciPy/Windows', ('*', '*', 'scipy'): 'http://www.scipy.org/Installing_SciPy', ('*', '*', 'setuptools'): 'https://pypi.python.org/pypi/setuptools#installation-instructions', ('*', '*', 'sqlite3'): 'http://www.sqlite.org/download.html', ('*', '*', 'sublime-text'): 'http://www.sublimetext.com/2', ('*', '*', 'sympy'): 'http://docs.sympy.org/dev/install.html', ('Darwin', '*', 'textmate'): 'http://macromates.com/', ('Darwin', '*', 'textwrangler'): 'http://www.barebones.com/products/textwrangler/download.html', ('*', '*', 'tornado'): 'http://www.tornadoweb.org/', ('*', '*', 'vim'): 'http://www.vim.org/download.php', ('Darwin', '*', 'xcode'): 'https://developer.apple.com/xcode/', ('*', '*', 'xemacs'): 'http://www.us.xemacs.org/Install/', ('*', '*', 'zsh'): 'http://www.zsh.org/', } def _get_message(self): return self._message def _set_message(self, message): self._message = message message = property(_get_message, _set_message) def __init__(self, checker, message, causes=None): super(DependencyError, self).__init__(message) self.checker = checker self.message = message if causes is None: causes = [] self.causes = causes def get_url(self): system = _platform.system() version = None for pversion in ( 'linux_distribution', 'mac_ver', 'win32_ver', ): value = getattr(_platform, pversion)() if value[0]: version = value[0] break package = self.checker.name for (s,v,p),url in self._setup_urls.items(): if (_fnmatch.fnmatch(system, s) and _fnmatch.fnmatch(version, v) and _fnmatch.fnmatch(package, p)): return url return self._default_url def __str__(self): url = self.get_url() lines = [ 'check for {0} failed:'.format(self.checker.full_name()), ' ' + self.message, ' For instructions on installing an up-to-date version, see', ' ' + url, ] if self.causes: lines.append(' causes:') for cause in self.causes: lines.extend(' ' + line for line in str(cause).splitlines()) return '\n'.join(lines) def check(checks=None): successes = [] failures = [] if not checks: checks = CHECKS for check in checks: try: checker = CHECKER[check] except KeyError as e: raise InvalidCheck(check)# from e _sys.stdout.write('check {0}...\t'.format(checker.full_name())) try: version = checker.check() except DependencyError as e: failures.append(e) _sys.stdout.write('fail\n') else: _sys.stdout.write('pass\n') successes.append((checker, version)) if successes: print('\nSuccesses:\n') for checker,version in successes: print('{0} {1}'.format( checker.full_name(), version or 'unknown')) if failures: print('\nFailures:') printed = [] for failure in failures: if failure not in printed: print() print(failure) printed.append(failure) return False return True class Dependency (object): def __init__(self, name, long_name=None, minimum_version=None, version_delimiter='.', and_dependencies=None, or_dependencies=None): self.name = name self.long_name = long_name or name self.minimum_version = minimum_version self.version_delimiter = version_delimiter if not and_dependencies: and_dependencies = [] self.and_dependencies = and_dependencies if not or_dependencies: or_dependencies = [] self.or_dependencies = or_dependencies self._check_error = None def __str__(self): return '<{0} {1}>'.format(type(self).__name__, self.name) def full_name(self): if self.name == self.long_name: return self.name else: return '{0} ({1})'.format(self.long_name, self.name) def check(self): if self._check_error: raise self._check_error try: self._check_dependencies() return self._check() except DependencyError as e: self._check_error = e # cache for future calls raise def _check_dependencies(self): for dependency in self.and_dependencies: if not hasattr(dependency, 'check'): dependency = CHECKER[dependency] try: dependency.check() except DependencyError as e: raise DependencyError( checker=self, message=( 'some dependencies for {0} were not satisfied' ).format(self.full_name()), causes=[e]) self.or_pass = None or_errors = [] for dependency in self.or_dependencies: if not hasattr(dependency, 'check'): dependency = CHECKER[dependency] try: version = dependency.check() except DependencyError as e: or_errors.append(e) else: self.or_pass = { 'dependency': dependency, 'version': version, } break # no need to test other dependencies if self.or_dependencies and not self.or_pass: raise DependencyError( checker=self, message=( '{0} requires at least one of the following dependencies' ).format(self.full_name()), causes=or_errors) def _check(self): version = self._get_version() parsed_version = None if hasattr(self, '_get_parsed_version'): parsed_version = self._get_parsed_version() if self.minimum_version: self._check_version(version=version, parsed_version=parsed_version) return version def _get_version(self): raise NotImplementedError(self) def _minimum_version_string(self): return self.version_delimiter.join( str(part) for part in self.minimum_version) def _check_version(self, version, parsed_version=None): if not parsed_version: parsed_version = self._parse_version(version=version) if not parsed_version or parsed_version < self.minimum_version: raise DependencyError( checker=self, message='outdated version of {0}: {1} (need >= {2})'.format( self.full_name(), version, self._minimum_version_string())) def _parse_version(self, version): if not version: return None parsed_version = [] for part in version.split(self.version_delimiter): try: parsed_version.append(int(part)) except ValueError as e: raise DependencyError( checker=self, message=( 'unparsable {0!r} in version {1} of {2}, (need >= {3})' ).format( part, version, self.full_name(), self._minimum_version_string()))# from e return tuple(parsed_version) class VirtualDependency (Dependency): def _check(self): return '{0} {1}'.format( self.or_pass['dependency'].full_name(), self.or_pass['version']) class CommandDependency (Dependency): exe_extension = _distutils_ccompiler.new_compiler().exe_extension def __init__(self, command, paths=None, version_options=('--version',), stdin=None, version_regexp=None, version_stream='stdout', **kwargs): if 'name' not in kwargs: kwargs['name'] = command super(CommandDependency, self).__init__(**kwargs) self.command = command self.paths = paths self.version_options = version_options self.stdin = None if not version_regexp: regexp = r'([\d][\d{0}]*[\d])'.format(self.version_delimiter) version_regexp = _re.compile(regexp) self.version_regexp = version_regexp self.version_stream = version_stream def _get_command_version_stream(self, command=None, stdin=None, expect=(0,)): if command is None: command = self.command + (self.exe_extension or '') if not stdin: stdin = self.stdin if stdin: popen_stdin = _subprocess.PIPE else: popen_stdin = None try: p = _subprocess.Popen( [command] + list(self.version_options), stdin=popen_stdin, stdout=_subprocess.PIPE, stderr=_subprocess.PIPE, universal_newlines=True) except OSError as e: raise DependencyError( checker=self, message="could not find '{0}' executable".format(command), )# from e stdout,stderr = p.communicate(stdin) status = p.wait() if status not in expect: lines = [ "failed to execute: {0} {1}".format( command, ' '.join(_shlex.quote(arg) for arg in self.version_options)), 'status: {0}'.format(status), ] for name,string in [('stdout', stdout), ('stderr', stderr)]: if string: lines.extend([name + ':', string]) raise DependencyError(checker=self, message='\n'.join(lines)) for name,string in [('stdout', stdout), ('stderr', stderr)]: if name == self.version_stream: if not string: raise DependencyError( checker=self, message='empty version stream on {0} for {1}'.format( self.version_stream, command)) return string raise NotImplementedError(self.version_stream) def _get_version_stream(self, **kwargs): paths = [self.command + (self.exe_extension or '')] if self.exe_extension: paths.append(self.command) # also look at the extension-less path if self.paths: paths.extend(self.paths) or_errors = [] for path in paths: try: return self._get_command_version_stream(command=path, **kwargs) except DependencyError as e: or_errors.append(e) raise DependencyError( checker=self, message='errors finding {0} version'.format( self.full_name()), causes=or_errors) def _get_version(self): version_stream = self._get_version_stream() match = self.version_regexp.search(version_stream) if not match: raise DependencyError( checker=self, message='no version string in output:\n{0}'.format( version_stream)) return match.group(1) class VersionPlistCommandDependency (CommandDependency): """A command that doesn't support --version or equivalent options On OS X, a command's executable may be hard to find, or not exist in the PATH. Work around that by looking up the version information in the package's version.plist file. """ def __init__(self, key='CFBundleShortVersionString', **kwargs): super(VersionPlistCommandDependency, self).__init__(**kwargs) self.key = key def _get_command_version_stream(self, *args, **kwargs): raise NotImplementedError() def _get_version_stream(self, *args, **kwargs): raise NotImplementedError() @staticmethod def _get_parent(root, element): """Returns the parent of this element or None for the root element """ for node in root.iter(): if element in node: return node raise ValueError((root, element)) @classmethod def _get_next(cls, root, element): """Returns the following sibling of this element or None """ parent = cls._get_parent(root=root, element=element) siblings = iter(parent) for node in siblings: if node == element: try: return next(siblings) except StopIteration: return None return None def _get_version_from_plist(self, path): """Parse the plist and return the value string for self.key """ tree = _element_tree.parse(source=path) data = {} for key in tree.findall('.//key'): value = self._get_next(root=tree, element=key) if value.tag != 'string': raise ValueError((tree, key, value)) data[key.text] = value.text return data[self.key] def _get_version(self): for path in self.paths: if _os.path.exists(path): return self._get_version_from_plist(path=path) raise DependencyError( checker=self, message=( 'nothing exists at any of the expected paths for {0}:\n {1}' ).format( self.full_name(), '\n '.join(p for p in self.paths))) class UserTaskDependency (Dependency): "Prompt the user to complete a task and check for success" def __init__(self, prompt, **kwargs): super(UserTaskDependency, self).__init__(**kwargs) self.prompt = prompt def _check(self): if _sys.version_info >= (3, ): result = input(self.prompt) else: # Python 2.x result = raw_input(self.prompt) return self._check_result(result) def _check_result(self, result): raise NotImplementedError() class EditorTaskDependency (UserTaskDependency): def __init__(self, **kwargs): self.path = _os.path.expanduser(_os.path.join( '~', 'swc-installation-test.txt')) self.contents = 'Hello, world!' super(EditorTaskDependency, self).__init__( prompt=( 'Open your favorite text editor and create the file\n' ' {0}\n' 'containing the line:\n' ' {1}\n' 'Press enter here after you have done this.\n' 'You may remove the file after you have finished testing.' ).format(self.path, self.contents), **kwargs) def _check_result(self, result): message = None try: with open(self.path, 'r') as f: contents = f.read() except IOError as e: raise DependencyError( checker=self, message='could not open {0!r}: {1}'.format(self.path, e) )# from e if contents.strip() != self.contents: raise DependencyError( checker=self, message=( 'file contents ({0!r}) did not match the expected {1!r}' ).format(contents, self.contents)) class MakeDependency (CommandDependency): makefile = '\n'.join([ 'all:', '\t@echo "MAKE_VERSION=$(MAKE_VERSION)"', '\t@echo "MAKE=$(MAKE)"', '', ]) def _get_version(self): try: return super(MakeDependency, self)._get_version() except DependencyError as e: version_options = self.version_options self.version_options = ['-f', '-'] try: stream = self._get_version_stream(stdin=self.makefile) info = {} for line in stream.splitlines(): try: key,value = line.split('=', 1) except ValueError as ve: raise e# from NotImplementedError(stream) info[key] = value if info.get('MAKE_VERSION', None): return info['MAKE_VERSION'] elif info.get('MAKE', None): return None raise e finally: self.version_options = version_options class EasyInstallDependency (CommandDependency): def _get_version(self): try: return super(EasyInstallDependency, self)._get_version() except DependencyError as e: version_stream = self.version_stream try: self.version_stream = 'stderr' stream = self._get_version_stream(expect=(1,)) if 'option --version not recognized' in stream: return 'unknown (possibly Setuptools?)' finally: self.version_stream = version_stream class PythonDependency (Dependency): def __init__(self, name='python', long_name='Python version', minimum_version=(2, 6), **kwargs): super(PythonDependency, self).__init__( name=name, long_name=long_name, minimum_version=minimum_version, **kwargs) def _get_version(self): return _sys.version def _get_parsed_version(self): return _sys.version_info class PythonPackageDependency (Dependency): def __init__(self, package, **kwargs): if 'name' not in kwargs: kwargs['name'] = package if 'and_dependencies' not in kwargs: kwargs['and_dependencies'] = [] if 'python' not in kwargs['and_dependencies']: kwargs['and_dependencies'].append('python') super(PythonPackageDependency, self).__init__(**kwargs) self.package = package def _get_version(self): package = self._get_package(self.package) return self._get_version_from_package(package) def _get_package(self, package): try: return _importlib.import_module(package) except ImportError as e: raise DependencyError( checker=self, message="could not import the '{0}' package for {1}".format( package, self.full_name()), )# from e def _get_version_from_package(self, package): try: version = package.__version__ except AttributeError: version = None return version class MercurialPythonPackage (PythonPackageDependency): def _get_version(self): try: # mercurial >= 1.2 package = _importlib.import_module('mercurial.util') except ImportError as e: # mercurial <= 1.1.2 package = self._get_package('mercurial.version') return package.get_version() else: return package.version() class TornadoPythonPackage (PythonPackageDependency): def _get_version_from_package(self, package): return package.version def _get_parsed_version(self): package = self._get_package(self.package) return package.version_info class SQLitePythonPackage (PythonPackageDependency): def _get_version_from_package(self, package): return _sys.version def _get_parsed_version(self): return _sys.version_info def _program_files_paths(*args): "Utility for generating MS Windows search paths" pf = _os.environ.get('ProgramFiles', '/usr/bin') pfx86 = _os.environ.get('ProgramFiles(x86)', pf) paths = [_os.path.join(pf, *args)] if pfx86 != pf: paths.append(_os.path.join(pfx86, *args)) return paths CHECKER['python'] = PythonDependency() for command,long_name,minimum_version,paths in [ ('sh', 'Bourne Shell', None, None), ('ash', 'Almquist Shell', None, None), ('bash', 'Bourne Again Shell', None, None), ('csh', 'C Shell', None, None), ('ksh', 'KornShell', None, None), ('dash', 'Debian Almquist Shell', None, None), ('tcsh', 'TENEX C Shell', None, None), ('zsh', 'Z Shell', None, None), ('git', 'Git', (1, 7, 0), None), ('hg', 'Mercurial', (2, 0, 0), None), ('EasyMercurial', None, (1, 3), None), ('pip', None, None, None), ('sqlite3', 'SQLite 3', None, None), ('nosetests', 'Nose', (1, 0, 0), None), ('ipython', 'IPython script', (1, 0), None), ('emacs', 'Emacs', None, None), ('xemacs', 'XEmacs', None, None), ('vim', 'Vim', None, None), ('vi', None, None, None), ('nano', 'Nano', None, None), ('gedit', None, None, None), ('kate', 'Kate', None, None), ('notepad++', 'Notepad++', None, _program_files_paths('Notepad++', 'notepad++.exe')), ('firefox', 'Firefox', None, _program_files_paths('Mozilla Firefox', 'firefox.exe')), ('google-chrome', 'Google Chrome', None, _program_files_paths('Google', 'Chrome', 'Application', 'chrome.exe') ), ('chromium', 'Chromium', None, None), ]: if not long_name: long_name = command CHECKER[command] = CommandDependency( command=command, paths=paths, long_name=long_name, minimum_version=minimum_version) del command, long_name, minimum_version, paths # cleanup namespace CHECKER['make'] = MakeDependency(command='make', minimum_version=None) CHECKER['easy_install'] = EasyInstallDependency( command='easy_install', long_name='Setuptools easy_install', minimum_version=None) CHECKER['py.test'] = CommandDependency( command='py.test', version_stream='stderr', minimum_version=None) for paths,name,long_name in [ ([_os.path.join(_ROOT_PATH, 'Applications', 'Sublime Text 2.app', 'Contents', 'version.plist')], 'sublime-text', 'Sublime Text'), ([_os.path.join(_ROOT_PATH, 'Applications', 'TextMate.app', 'Contents', 'version.plist')], 'textmate', 'TextMate'), ([_os.path.join(_ROOT_PATH, 'Applications', 'TextWrangler.app', 'Contents', 'version.plist')], 'textwrangler', 'TextWrangler'), ([_os.path.join(_ROOT_PATH, 'Applications', 'Safari.app', 'Contents', 'version.plist')], 'safari', 'Safari'), ([_os.path.join(_ROOT_PATH, 'Applications', 'Xcode.app', 'Contents', 'version.plist'), # OS X >=1.7 _os.path.join(_ROOT_PATH, 'Developer', 'Applications', 'Xcode.app', 'Contents', 'version.plist'), # OS X 1.6, ], 'xcode', 'Xcode'), ]: if not long_name: long_name = name CHECKER[name] = VersionPlistCommandDependency( command=None, paths=paths, name=name, long_name=long_name) del paths, name, long_name # cleanup namespace for package,name,long_name,minimum_version,and_dependencies in [ ('nose', None, 'Nose Python package', CHECKER['nosetests'].minimum_version, None), ('pytest', None, 'pytest Python package', CHECKER['py.test'].minimum_version, None), ('jinja2', 'jinja', 'Jinja', (2, 6), None), ('zmq', 'pyzmq', 'PyZMQ', (2, 1, 4), None), ('IPython', None, 'IPython Python package', CHECKER['ipython'].minimum_version, [ 'jinja', 'tornado', 'pyzmq', VirtualDependency( name='virtual-browser-ipython', long_name='IPython-compatible web browser', or_dependencies=[ CommandDependency( command=CHECKER['firefox'].command, paths=CHECKER['firefox'].paths, name='{0}-for-ipython'.format( CHECKER['firefox'].name), long_name='{0} for IPython'.format( CHECKER['firefox'].long_name), minimum_version=(6, 0)), CommandDependency( command=CHECKER['google-chrome'].command, paths=CHECKER['google-chrome'].paths, name='{0}-for-ipython'.format( CHECKER['google-chrome'].name), long_name='{0} for IPython'.format( CHECKER['google-chrome'].long_name), minimum_version=(13, 0)), CommandDependency( command=CHECKER['chromium'].command, paths=CHECKER['chromium'].paths, name='{0}-for-ipython'.format( CHECKER['chromium'].name), long_name='{0} for IPython'.format( CHECKER['chromium'].long_name), minimum_version=(13, 0)), VersionPlistCommandDependency( command=CHECKER['safari'].command, paths=CHECKER['safari'].paths, key=CHECKER['safari'].key, name='{0}-for-ipython'.format( CHECKER['safari'].name), long_name='{0} for IPython'.format( CHECKER['safari'].long_name), minimum_version=(5, 0)), ]), ]), ('argparse', None, 'Argparse', None, None), ('numpy', None, 'NumPy', None, None), ('scipy', None, 'SciPy', None, None), ('matplotlib', None, 'Matplotlib', None, None), ('pandas', None, 'Pandas', (0, 8), None), ('sympy', None, 'SymPy', None, None), ('Cython', None, None, None, None), ('networkx', None, 'NetworkX', None, None), ('mayavi.mlab', None, 'MayaVi', None, None), ('setuptools', None, 'Setuptools', None, None), ]: if not name: name = package if not long_name: long_name = name kwargs = {} if and_dependencies: kwargs['and_dependencies'] = and_dependencies CHECKER[name] = PythonPackageDependency( package=package, name=name, long_name=long_name, minimum_version=minimum_version, **kwargs) # cleanup namespace del package, name, long_name, minimum_version, and_dependencies, kwargs CHECKER['mercurial'] = MercurialPythonPackage( package='mercurial.util', name='mercurial', long_name='Mercurial Python package', minimum_version=CHECKER['hg'].minimum_version) CHECKER['tornado'] = TornadoPythonPackage( package='tornado', name='tornado', long_name='Tornado', minimum_version=(2, 0)) CHECKER['sqlite3-python'] = SQLitePythonPackage( package='sqlite3', name='sqlite3-python', long_name='SQLite Python package', minimum_version=CHECKER['sqlite3'].minimum_version) CHECKER['other-editor'] = EditorTaskDependency( name='other-editor', long_name='') for name,long_name,dependencies in [ ('virtual-shell', 'command line shell', ( 'bash', 'dash', 'ash', 'zsh', 'ksh', 'csh', 'tcsh', 'sh', )), ('virtual-editor', 'text/code editor', ( 'emacs', 'xemacs', 'vim', 'vi', 'nano', 'gedit', 'kate', 'notepad++', 'sublime-text', 'textmate', 'textwrangler', 'other-editor', # last because it requires user interaction )), ('virtual-browser', 'web browser', ( 'firefox', 'google-chrome', 'chromium', 'safari', )), ('virtual-pypi-installer', 'PyPI installer', ( 'pip', 'easy_install', )), ]: CHECKER[name] = VirtualDependency( name=name, long_name=long_name, or_dependencies=dependencies) del name, long_name, dependencies # cleanup namespace def _print_info(key, value, indent=19): print('{0}{1}: {2}'.format(key, ' '*(indent-len(key)), value)) def print_system_info(): print("If you do not understand why the above failures occurred,") print("copy and send the *entire* output (all info above and summary") print("below) to the instructor for help.") print() print('==================') print('System information') print('==================') _print_info('os.name', _os.name) _print_info('os.uname', _platform.uname()) _print_info('platform', _sys.platform) _print_info('platform+', _platform.platform()) for pversion in ( 'linux_distribution', 'mac_ver', 'win32_ver', ): value = getattr(_platform, pversion)() if value[0]: _print_info(pversion, value) _print_info('prefix', _sys.prefix) _print_info('exec_prefix', _sys.exec_prefix) _print_info('executable', _sys.executable) _print_info('version_info', _sys.version_info) _print_info('version', _sys.version) _print_info('environment', '') for key,value in sorted(_os.environ.items()): print(' {0}={1}'.format(key, value)) print('==================') def print_suggestions(instructor_fallback=True): print() print('For suggestions on installing missing packages, see') print('http://software-carpentry.org/setup/') print('') print('For instructings on installing a particular package,') print('see the failure message for that package printed above.') if instructor_fallback: print('') print('For help, email the *entire* output of this script to') print('your instructor.') if __name__ == '__main__': import optparse as _optparse parser = _optparse.OptionParser(usage='%prog [options] [check...]') epilog = __doc__ parser.format_epilog = lambda formatter: '\n' + epilog parser.add_option( '-v', '--verbose', action='store_true', help=('print additional information to help troubleshoot ' 'installation issues')) options,args = parser.parse_args() try: passed = check(args) except InvalidCheck as e: print("I don't know how to check for {0!r}".format(e.check)) print('I do know how to check for:') for key,checker in sorted(CHECKER.items()): if checker.long_name != checker.name: print(' {0} {1}({2})'.format( key, ' '*(20-len(key)), checker.long_name)) else: print(' {0}'.format(key)) _sys.exit(1) if not passed: if options.verbose: print() print_system_info() print_suggestions(instructor_fallback=True) _sys.exit(1)