""" A version of the ``build_sphinx`` command that uses the

description = 'Build Sphinx documentation for Astropy environment'

user_options = BuildDoc.user_options[:]

user_options.append(('clean-docs', 'l', 'Clean previously-built docs '

'before building new ones'))

boolean_options = BuildDoc.boolean_options[:]

boolean_options.append('clean-docs')

_self_iden_rex = re.compile(r"self\.([^\d\W][\w]+)", re.UNICODE)

def initialize_options(self):

BuildDoc.initialize_options(self)

self.clean_docs = False

def finalize_options(self):

from os.path import isdir

from shutil import rmtree

#Clear out previous sphinx builds, if requested

if self.clean_docs:

dirstorm = ['docs/_generated']

if self.build_dir is None:

dirstorm.append('docs/_build')

else:

dirstorm.append(self.build_dir)

for d in dirstorm:

if isdir(d):

log.info('Cleaning directory ' + d)

rmtree(d)

else:

log.info('Not cleaning directory ' + d + ' because '

'not present or not a directory')

BuildDoc.finalize_options(self)

def run(self):

from os.path import split, join

from distutils.cmd import DistutilsOptionError

from subprocess import Popen, PIPE

from textwrap import dedent

from inspect import getsourcelines

# If possible, create the _static dir

if self.build_dir is not None:

# the _static dir should be in the same place as the _build dir

# for Astropy

basedir, subdir = split(self.build_dir)

if subdir == '': # the path has a trailing /...

basedir, subdir = split(basedir)

staticdir = join(basedir, '_static')

if os.path.isfile(staticdir):

raise DistutilsOptionError(

'Attempted to build_sphinx in a location where' +

staticdir + 'is a file. Must be a directory.')

self.mkpath(staticdir)

#Now make sure Astropy is built and determine where it was built

build_cmd = self.reinitialize_command('build')

build_cmd.inplace = 0

self.run_command('build')

build_cmd = self.get_finalized_command('build')

build_cmd_path = os.path.abspath(build_cmd.build_lib)

#Now generate the source for and spawn a new process that runs the

#command. This is needed to get the correct imports for the built

#version

runlines, runlineno = getsourcelines(BuildDoc.run)

subproccode = dedent("""

""").format(build_cmd_path=build_cmd_path, srcdir=self.source_dir)

#runlines[1:] removes 'def run(self)' on the first line

subproccode += dedent(''.join(runlines[1:]))

# All "self.foo" in the subprocess code needs to be replaced by the

# values taken from the current self in *this* process

subproccode = AstropyBuildSphinx._self_iden_rex.split(subproccode)

for i in range(1, len(subproccode), 2):

iden = subproccode[i]

val = getattr(self, iden)

if iden.endswith('_dir'):

#Directories should be absolute, because the `chdir` call

#in the new process moves to a different directory

subproccode[i] = repr(os.path.abspath(val))

else:

subproccode[i] = repr(val)

subproccode = ''.join(subproccode)

log.debug('Starting subprocess of {0} with python code:\n{1}\n'

'[CODE END])'.format(sys.executable, subproccode))

proc = Popen([sys.executable], stdin=PIPE)

proc.communicate(subproccode)

if proc.returncode != 0:

log.warn('Sphinx Documentation subprocess failed with return '

""" Returns a set of all the distutils display options in their long and

short_display_opts = set('-' + o[1] for o in Distribution.display_options

if o[1])

long_display_opts = set('--' + o[0] for o in Distribution.display_options)

""" Returns True if sys.argv contains any of the distutils display options

display_options = get_distutils_display_options()

""" Returns the value of the given distutils option.

display_opts = get_distutils_display_options()

args = [arg for arg in sys.argv[1:] if arg not in display_opts]

# Pre-parse the Distutils command-line options and config files to

# if the option is set.

dist = Distribution({'script_name': os.path.basename(sys.argv[0]),

'script_args': args})

try:

dist.parse_config_files()

dist.parse_command_line()

except DistutilsError:

# Let distutils handle this itself

return None

except AttributeError:

# This seems to get thrown for ./setup.py --help

return None

for cmd in commands:

if cmd in dist.commands:

break

else:

return None

for cmd in commands:

cmd_opts = dist.get_option_dict(cmd)

if option in cmd_opts:

return cmd_opts[option][1]

else:

""" Determines the compiler that will be used to build extension modules.

compiler = get_distutils_option('compiler',

['build', 'build_ext', 'build_clib'])

if compiler is None:

import distutils.ccompiler

return distutils.ccompiler.get_default_compiler()

""" Determines if the build is in debug mode.

debug = bool(get_distutils_option(

'debug', ['build', 'build_ext', 'build_clib']))

try:

from astropy.version import debug as current_debug

except ImportError:

current_debug = None

if current_debug is not None and current_debug != debug:

# Force rebuild of extension modules

sys.argv.extend(['build', '--force'])

package_dirs):

""" Extends existing extensions, package_data, packagenames and

from astropy.version import release

# For each of the setup_package.py modules, extract any information that is

# needed to install them.

for setuppkg in iter_setup_packages(srcdir):

# get_extensions must include any Cython extensions by their .pyx

# filename.

if hasattr(setuppkg, 'get_extensions'):

extensions.extend(setuppkg.get_extensions())

if hasattr(setuppkg, 'get_package_data'):

package_data.update(setuppkg.get_package_data())

if hasattr(setuppkg, 'get_legacy_alias'):

pkg, dir = setuppkg.get_legacy_alias()

if pkg is not None:

packagenames.append(pkg)

package_dirs[pkg] = dir

# Locate any .pyx files not already specified, and add their extensions in.

# The default include dirs include numpy to facilitate numerical work.

extensions.extend(get_cython_extensions(srcdir, extensions,

[numpy_includes]))

# Now remove extensions that have the special name 'skip_cython', as they

# exist Only to indicate that the cython extensions shouldn't be built

for i, ext in reversed(list(enumerate(extensions))):

if ext.name == 'skip_cython':

del extensions[i]

if release or not HAVE_CYTHON:

# Replace .pyx with C-equivalents, unless c files are missing

for idx, ext in reversed(list(enumerate(extensions))):

for jdx, src in enumerate(ext.sources):

if src.endswith('.pyx'):

pyxfn = src

cfn = src[:-4] + '.c'

elif src.endswith('.c'):

pyxfn = src[:-2] + '.pyx'

cfn = src

if os.path.isfile(pyxfn):

if os.path.isfile(cfn):

ext.sources[jdx] = cfn

else:

raise IOError(

'Could not find C file {0} for Cython file {1} '

'when building extension {2}. '

'Cython must be installed to build from a git '

'checkout'.format(cfn, pyxfn, ext.name))

# On Microsoft compilers, we need to pass the '/MANIFEST'

# commandline argument. This was the default on MSVC 9.0, but is

# now required on MSVC 10.0, but it doesn't seeem to hurt to add

# it unconditionally.

if get_compiler_option() == 'msvc':

for ext in extensions:

""" A generator that finds and imports all of the ``setup_package.py``

for root, dirs, files in os.walk(srcdir):

if 'setup_package.py' in files:

filename = os.path.join(root, 'setup_package.py')

module = import_file(filename)

""" A generator that yields Cython source files (ending in '.pyx') in the

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

modbase = dirpath.replace(os.sep, '.')

for fn in filenames:

if fn.endswith('.pyx'):

fullfn = os.path.join(dirpath, fn)

# Package must match file name

extmod = modbase + '.' + fn[:-4]

""" Looks for Cython files and generates Extensions if needed.

prevpyxpaths = []

for ext in prevextensions:

for s in ext.sources:

if s.endswith('.pyx'):

prevpyxpaths.append(os.path.realpath(s))

ext_modules = []

for extmod, pyxfn in iter_pyx_files(srcdir):

if os.path.realpath(pyxfn) not in prevpyxpaths:

ext_modules.append(Extension(extmod, [pyxfn],

include_dirs=extincludedirs))

""" Write `data` to `filename`, if the content of the file is different.

assert isinstance(data, bytes)

if os.path.exists(filename):

with open(filename, 'rb') as fd:

original_data = fd.read()

else:

original_data = None

if original_data != data:

with open(filename, 'wb') as fd:

"""

import numpy

major, minor, rest = numpy.__version__.split(".", 2)

if (int(major), int(minor)) < (1, 4):

msg = "numpy version 1.4 or later must be installed to build astropy"

"""

import numpy

try:

numpy_include = numpy.get_include()

except AttributeError:

numpy_include = numpy.get_numpy_include()

"""

global _adjusted_compiler

if _adjusted_compiler:

return

# Whatever the result of this function is, it only needs to be run once

_adjusted_compiler = True

if 'CC' in os.environ:

return

if get_distutils_option(

'compiler', ['build', 'build_ext', 'build_clib']) is not None:

return

from distutils import ccompiler, sysconfig

import subprocess

import re

compiler_mapping = [

(b'i686-apple-darwin[0-9]*-llvm-gcc-4.2', 'clang')

]

compiler_type = ccompiler.get_default_compiler()

if compiler_type == 'unix':

# We have to get the compiler this way, as this is the one that is

# used if os.environ['CC'] is not set. It is actually read in from

# the Python Makefile. Note that this is not necessarily the same

# compiler as returned by ccompiler.new_compiler()

c_compiler = sysconfig.get_config_var('CC')

process = subprocess.Popen(

shlex.split(c_compiler) + ['--version'], stdout=subprocess.PIPE)

output = process.communicate()[0].strip()

version = output.split()[0]

for broken, fixed in compiler_mapping:

if re.match(broken, version):

os.environ['CC'] = fixed

"""

#_ASTROPY_SETUP_ is added to the builtins in setup.py or astropy/__init__.py

"""

from sys import version_info

if version_info[0] >= 3:

import builtins

else:

import __builtin__ as builtins

"""

# Specifying a traditional dot-separated fully qualified name here

# results in a number of "Parent module 'astropy' not found while

# handling absolute import" warnings. Using the same name, the

# namespaces of the modules get merged together. So, this

# generates an underscore-separated name which is more likely to

# be unique, and it doesn't really matter because the name isn't

# used directly here anyway.

with open(filename, 'U') as fd:

name = '_'.join(

os.path.relpath(os.path.splitext(filename)[0]).split(os.sep)[1:])

"""

import imp

found_legacy_module = True

try:

location = imp.find_module(old_package)

except ImportError:

found_legacy_module = False

else:

# We want ImportError to raise here, because that means it was

# found, but something else went wrong.

# We could import the module here to determine if its "real"

# or just a legacy alias. However, importing the legacy alias

# may cause importing of code within the astropy source tree,

# which may require 2to3 to have been run. It's safer to just

# open the file and search for a string.

filename = os.path.join(location[1], '__init__.py')

if os.path.exists(filename):

with open(filename, 'U') as fd:

if '_is_astropy_legacy_alias' in fd.read():

found_legacy_module = False

shim_dir = os.path.join(get_legacy_alias_dir(), old_package)

if found_legacy_module and not is_distutils_display_option():

warn('-' * 60)

warn("The legacy package '{0}' was found.".format(old_package))

warn("To install astropy's compatibility layer instead, uninstall")

warn("'{0}' and then reinstall astropy.".format(old_package))

warn('-' * 60)

if os.path.isdir(shim_dir):

shutil.rmtree(shim_dir)

return (None, None)

if extras:

extras = '\n'.join('{0} = {1!r}'.format(*v) for v in extras.items())

else:

extras = ''

if not os.path.isdir(shim_dir):

os.makedirs(shim_dir)

content = legacy_shim_template.format(**locals()).encode('utf-8')

write_if_different(

os.path.join(shim_dir, '__init__.py'), content)