"""Return true if test is a file and its name does NOT end with any

if not isfile(test):

return False

for e in endings:

if test.endswith(e):

return False

name = name,

version = version,

description = description,

long_description = long_description,

author = author,

author_email = author_email,

url = url,

download_url = download_url,

license = license,

platforms = platforms,

keywords = keywords,

classifiers = classifiers,

cmdclass = {'install_data': install_data_ext},

"""

excludes = ['deathrow', 'quarantine']

packages = []

for dir,subdirs,files in os.walk('IPython'):

package = dir.replace(os.path.sep, '.')

if any(package.startswith('IPython.'+exc) for exc in excludes):

# package is to be excluded (e.g. deathrow)

continue

if '__init__.py' not in files:

# not a package

continue

packages.append(package)

"""

# This is not enough for these things to appear in an sdist.

# We need to muck with the MANIFEST to get this to work

# exclude components and less from the walk;

# we will build the components separately

excludes = [

pjoin('static', 'components'),

pjoin('static', '*', 'less'),

]

# walk notebook resources:

cwd = os.getcwd()

os.chdir(os.path.join('IPython', 'html'))

static_data = []

for parent, dirs, files in os.walk('static'):

if any(fnmatch(parent, pat) for pat in excludes):

# prevent descending into subdirs

dirs[:] = []

continue

for f in files:

static_data.append(pjoin(parent, f))

components = pjoin("static", "components")

# select the components we actually need to install

# (there are lots of resources we bundle for sdist-reasons that we don't actually use)

static_data.extend([

pjoin(components, "backbone", "backbone-min.js"),

pjoin(components, "bootstrap", "js", "bootstrap.min.js"),

pjoin(components, "bootstrap-tour", "build", "css", "bootstrap-tour.min.css"),

pjoin(components, "bootstrap-tour", "build", "js", "bootstrap-tour.min.js"),

pjoin(components, "font-awesome", "fonts", "*.*"),

pjoin(components, "google-caja", "html-css-sanitizer-minified.js"),

pjoin(components, "highlight.js", "build", "highlight.pack.js"),

pjoin(components, "jquery", "jquery.min.js"),

pjoin(components, "jquery-ui", "ui", "minified", "jquery-ui.min.js"),

pjoin(components, "jquery-ui", "themes", "smoothness", "jquery-ui.min.css"),

pjoin(components, "jquery-ui", "themes", "smoothness", "images", "*"),

pjoin(components, "marked", "lib", "marked.js"),

pjoin(components, "requirejs", "require.js"),

pjoin(components, "underscore", "underscore-min.js"),

pjoin(components, "moment", "moment.js"),

pjoin(components, "moment", "min", "moment.min.js"),

pjoin(components, "term.js", "src", "term.js"),

pjoin(components, "text-encoding", "lib", "encoding.js"),

])

# Ship all of Codemirror's CSS and JS

for parent, dirs, files in os.walk(pjoin(components, 'codemirror')):

for f in files:

if f.endswith(('.js', '.css')):

static_data.append(pjoin(parent, f))

os.chdir(os.path.join('tests',))

js_tests = glob('*.js') + glob('*/*.js')

os.chdir(os.path.join(cwd, 'IPython', 'nbconvert'))

nbconvert_templates = [os.path.join(dirpath, '*.*')

for dirpath, _, _ in os.walk('templates')]

os.chdir(cwd)

package_data = {

'IPython.config.profile' : ['README*', '*/*.py'],

'IPython.core.tests' : ['*.png', '*.jpg'],

'IPython.lib.tests' : ['*.wav'],

'IPython.testing.plugin' : ['*.txt'],

'IPython.html' : ['templates/*'] + static_data,

'IPython.html.tests' : js_tests,

'IPython.qt.console' : ['resources/icon/*.svg'],

'IPython.nbconvert' : nbconvert_templates +

[

'tests/files/*.*',

'exporters/tests/files/*.*',

'preprocessors/tests/files/*.*',

],

'IPython.nbconvert.filters' : ['marked.js'],

'IPython.nbformat' : [

'tests/*.ipynb',

'v3/nbformat.v3.schema.json',

'v4/nbformat.v4.schema.json',

]

}

"""verify that package_data globs make sense"""

print("checking package data")

for pkg, data in package_data.items():

pkg_root = pjoin(*pkg.split('.'))

for d in data:

path = pjoin(pkg_root, d)

if '*' in path:

assert len(glob(path)) > 0, "No files match pattern %s" % path

else:

"""decorator for checking package_data before running a given command

class DecoratedCommand(command):

def run(self):

check_package_data(self.package_data)

command.run(self)

"""Make the directory structure of all files below a starting dir.

# we'll use these a lot below

lbase = len(base)

pathsep = os.path.sep

lpathsep = len(pathsep)

out = []

for (dirpath,dirnames,filenames) in os.walk(base):

# we need to strip out the dirpath from the base to map it to the

# output (installation) path. This requires possibly stripping the

# path separator, because otherwise pjoin will not work correctly

# (pjoin('foo/','/bar') returns '/bar').

dp_eff = dirpath[lbase:]

if dp_eff.startswith(pathsep):

dp_eff = dp_eff[lpathsep:]

# The output path must be anchored at the out_base marker

out_path = pjoin(out_base,dp_eff)

# Now we can generate the final filenames. Since os.walk only produces

# filenames, we must join back with the dirpath to get full valid file

# paths:

pfiles = [pjoin(dirpath,f) for f in filenames]

# Finally, generate the entry we need, which is a pari of (output

# path, files) for use as a data_files parameter in install_data.

out.append((out_path, pfiles))

"""

manpagebase = pjoin('share', 'man', 'man1')

# Simple file lists can be made by hand

manpages = [f for f in glob(pjoin('docs','man','*.1.gz')) if isfile(f)]

if not manpages:

# When running from a source tree, the manpages aren't gzipped

manpages = [f for f in glob(pjoin('docs','man','*.1')) if isfile(f)]

# And assemble the entire output list

data_files = [ (manpagebase, manpages) ]

"""Return a target_update-compliant tuple for the given manpage.

man_dir = pjoin('docs', 'man')

manpage_gz = manpage + '.gz'

manpath = pjoin(man_dir, manpage)

manpath_gz = pjoin(man_dir, manpage_gz)

gz_cmd = ( "cd %(man_dir)s && gzip -9c %(manpage)s > %(manpage_gz)s" %

locals() )

"""Determine whether a target is out of date.

try:

target_time = os.path.getmtime(target)

except os.error:

return 1

for dep in deps:

dep_time = os.path.getmtime(dep)

if dep_time > target_time:

#print "For target",target,"Dep failed:",dep # dbg

#print "times (dep,tar):",dep_time,target_time # dbg

return 1

"""Update a target with a given command given a list of dependencies.

if target_outdated(target,deps):

"""Find IPython's scripts.

ep = [

'ipython%s = IPython:start_ipython',

'ipcontroller%s = IPython.parallel.apps.ipcontrollerapp:launch_new_instance',

'ipengine%s = IPython.parallel.apps.ipengineapp:launch_new_instance',

'ipcluster%s = IPython.parallel.apps.ipclusterapp:launch_new_instance',

'iptest%s = IPython.testing.iptestcontroller:main',

]

suffix = str(sys.version_info[0])

def run(self):

self.mkpath(self.build_dir)

outfiles = []

for script in find_entry_points():

name, entrypt = script.split('=')

name = name.strip()

entrypt = entrypt.strip()

outfile = os.path.join(self.build_dir, name)

outfiles.append(outfile)

print('Writing script to', outfile)

mod, func = entrypt.split(':')

with open(outfile, 'w') as f:

f.write(script_src.format(executable=sys.executable,

mod=mod, func=func))

user_options = [

('install-dir=', 'd', "directory to install to"),

]

def initialize_options(self):

self.install_dir = None

def finalize_options(self):

self.set_undefined_options('symlink',

('install_lib', 'install_dir'),

)

def run(self):

if sys.platform == 'win32':

raise Exception("This doesn't work on Windows.")

pkg = os.path.join(os.getcwd(), 'IPython')

dest = os.path.join(self.install_dir, 'IPython')

if os.path.islink(dest):

print('removing existing symlink at %s' % dest)

os.unlink(dest)

print('symlinking %s -> %s' % (pkg, dest))

def run(self):

dest = os.path.join(self.install_lib, 'IPython')

if os.path.islink(dest):

print('removing symlink at %s' % dest)

os.unlink(dest)

else:

def run(self):

if sys.platform == 'win32':

raise Exception("This doesn't work on Windows.")

# Run all sub-commands (at least those that need to be run)

for cmd_name in self.get_sub_commands():

self.run_command(cmd_name)

# 'sub_commands': a list of commands this command might have to run to

# get its work done. See cmd.py for more info.

sub_commands = [('install_lib_symlink', lambda self:True),

('install_scripts_sym', lambda self:True),

"""Redefined to get options from 'symlink' instead of 'install'.

def finalize_options(self):

self.set_undefined_options('build', ('build_scripts', 'build_dir'))

self.set_undefined_options('symlink',

('install_scripts', 'install_dir'),

('force', 'force'),

('skip_build', 'skip_build'),

"""Check for IPython's dependencies.

from setupext.setupext import (

print_line, print_raw, print_status,

check_for_sphinx, check_for_pygments,

check_for_nose, check_for_pexpect,

check_for_pyzmq, check_for_readline,

check_for_jinja2, check_for_tornado

)

print_line()

print_raw("BUILDING IPYTHON")

print_status('python', sys.version)

print_status('platform', sys.platform)

if sys.platform == 'win32':

print_status('Windows version', sys.getwindowsversion())

print_raw("")

print_raw("OPTIONAL DEPENDENCIES")

check_for_sphinx()

check_for_pygments()

check_for_nose()

if os.name == 'posix':

check_for_pexpect()

check_for_pyzmq()

check_for_tornado()

check_for_readline()

"""Update git submodules

description = "Update git submodules"

user_options = []

def initialize_options(self):

pass

def finalize_options(self):

pass

def run(self):

failure = False

try:

self.spawn('git submodule init'.split())

self.spawn('git submodule update --recursive'.split())

except Exception as e:

failure = e

print(e)

if not check_submodule_status(repo_root) == 'clean':

print("submodules could not be checked out")

"""Return extended build or sdist command class for recording commit

class MyBuildPy(build_cmd):

''' Subclass to write commit data into installation tree '''

def run(self):

build_cmd.run(self)

# this one will only fire for build commands

if hasattr(self, 'build_lib'):

self._record_commit(self.build_lib)

def make_release_tree(self, base_dir, files):

# this one will fire for sdist

build_cmd.make_release_tree(self, base_dir, files)

self._record_commit(base_dir)

def _record_commit(self, base_dir):

import subprocess

proc = subprocess.Popen('git rev-parse --short HEAD',

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

shell=True)

repo_commit, _ = proc.communicate()

repo_commit = repo_commit.strip().decode("ascii")

out_pth = pjoin(base_dir, pkg_dir, 'utils', '_sysinfo.py')

if os.path.isfile(out_pth) and not repo_commit:

# nothing to write, don't clobber

return

print("writing git commit '%s' to %s" % (repo_commit, out_pth))

# remove to avoid overwriting original via hard link

try:

os.remove(out_pth)

except (IOError, OSError):

pass

with open(out_pth, 'w') as out_file:

out_file.writelines([

'# GENERATED BY setup.py\n',

'commit = u"%s"\n' % repo_commit,

])

"""decorator for instructing a command to check for submodules before running"""

class DecoratedCommand(command):

def run(self):

if not check_submodule_status(repo_root) == 'clean':

print("submodules missing! Run `setup.py submodule` and try again")

sys.exit(1)

command.run(self)

"""Construct bdist_wheel command for building wheels

class RequiresWheel(Command):

description = "Dummy command for missing bdist_wheel"

user_options = []

def initialize_options(self):

pass

def finalize_options(self):

pass

def run(self):

print("bdist_wheel requires the wheel package")

sys.exit(1)

if 'setuptools' not in sys.modules:

return RequiresWheel

else:

try:

from wheel.bdist_wheel import bdist_wheel, read_pkg_info, write_pkg_info

except ImportError:

return RequiresWheel

class bdist_wheel_tag(bdist_wheel):

def add_requirements(self, metadata_path):

"""transform platform-dependent requirements"""

pkg_info = read_pkg_info(metadata_path)

# pkg_info is an email.Message object (?!)

# we have to remove the unconditional 'readline' and/or 'pyreadline' entries

# and transform them to conditionals

requires = pkg_info.get_all('Requires-Dist')

del pkg_info['Requires-Dist']

def _remove_startswith(lis, prefix):

"""like list.remove, but with startswith instead of =="""

found = False

for idx, item in enumerate(lis):

if item.startswith(prefix):

found = True

break

if found:

lis.pop(idx)

for pkg in ("gnureadline", "pyreadline", "mock"):

_remove_startswith(requires, pkg)

requires.append("gnureadline; sys.platform == 'darwin' and platform.python_implementation == 'CPython'")

requires.append("pyreadline (>=2.0); extra == 'terminal' and sys.platform == 'win32' and platform.python_implementation == 'CPython'")

requires.append("pyreadline (>=2.0); extra == 'all' and sys.platform == 'win32' and platform.python_implementation == 'CPython'")

requires.append("mock; extra == 'test' and python_version < '3.3'")

for r in requires:

pkg_info['Requires-Dist'] = r

write_pkg_info(metadata_path, pkg_info)

"""Recompile Notebook CSS

description = "Recompile Notebook CSS"

user_options = [

('minify', 'x', "minify CSS"),

('force', 'f', "force recompilation of CSS"),

]

def initialize_options(self):

self.minify = False

self.force = False

def finalize_options(self):

self.minify = bool(self.minify)

self.force = bool(self.force)

def run(self):

cmd = ['invoke', 'css']

if self.minify:

cmd.append('--minify')

if self.force:

cmd.append('--force')

"""write the javascript version to notebook javascript"""

description = "Write IPython version to javascript"

user_options = []

def initialize_options(self):

pass

def finalize_options(self):

pass

def run(self):

nsfile = pjoin(repo_root, "IPython", "html", "static", "base", "js", "namespace.js")

with open(nsfile) as f:

lines = f.readlines()

with open(nsfile, 'w') as f:

for line in lines:

if line.startswith("IPython.version"):

line = 'IPython.version = "{0}";\n'.format(version)

"""decorator for building js/minified css prior to a release"""

class DecoratedCommand(command):

def run(self):

self.distribution.run_command('jsversion')

css = self.distribution.get_command_obj('css')

css.minify = True

try:

self.distribution.run_command('css')

except Exception as e:

if strict:

raise

else:

log.warn("Failed to build css sourcemaps: %s" % e)

command.run(self)