import os

import re

import sys

import imp

import copy

import glob

import atexit

import tempfile

import subprocess

import shutil

import distutils

from distutils.errors import DistutilsError

try:

set

except NameError:

from sets import Set as set

from numpy.distutils.compat import get_exception

__all__ = ['Configuration', 'get_numpy_include_dirs', 'default_config_dict',

'dict_append', 'appendpath', 'generate_config_py',

'get_cmd', 'allpath', 'get_mathlibs',

'terminal_has_colors', 'red_text', 'green_text', 'yellow_text',

'blue_text', 'cyan_text', 'cyg2win32','mingw32','all_strings',

'has_f_sources', 'has_cxx_sources', 'filter_sources',

'get_dependencies', 'is_local_src_dir', 'get_ext_source_files',

'get_script_files', 'get_lib_source_files', 'get_data_files',

'dot_join', 'get_frame', 'minrelpath','njoin',

'is_sequence', 'is_string', 'as_list', 'gpaths', 'get_language',

'quote_args', 'get_build_architecture', 'get_info', 'get_pkg_info']

class InstallableLib(object):

"""

Container to hold information on an installable library.

Parameters

----------

name : str

Name of the installed library.

build_info : dict

Dictionary holding build information.

target_dir : str

Absolute path specifying where to install the library.

See Also

--------

Configuration.add_installed_library

Notes

-----

The three parameters are stored as attributes with the same names.

"""

def __init__(self, name, build_info, target_dir):

self.name = name

self.build_info = build_info

self.target_dir = target_dir

def quote_args(args):

# don't used _nt_quote_args as it does not check if

# args items already have quotes or not.

args = list(args)

for i in range(len(args)):

a = args[i]

if ' ' in a and a[0] not in '"\'':

args[i] = '"%s"' % (a)

return args

def allpath(name):

"Convert a /-separated pathname to one using the OS's path separator."

splitted = name.split('/')

return os.path.join(*splitted)

def rel_path(path, parent_path):

"""Return path relative to parent_path.

"""

pd = os.path.abspath(parent_path)

apath = os.path.abspath(path)

if len(apath)<len(pd):

return path

if apath==pd:

return ''

if pd == apath[:len(pd)]:

assert apath[len(pd)] in [os.sep],repr((path,apath[len(pd)]))

path = apath[len(pd)+1:]

return path

def get_path_from_frame(frame, parent_path=None):

"""Return path of the module given a frame object from the call stack.

Returned path is relative to parent_path when given,

otherwise it is absolute path.

"""

# First, try to find if the file name is in the frame.

try:

caller_file = eval('__file__', frame.f_globals, frame.f_locals)

d = os.path.dirname(os.path.abspath(caller_file))

except NameError:

# __file__ is not defined, so let's try __name__. We try this second

# because setuptools spoofs __name__ to be '__main__' even though

# sys.modules['__main__'] might be something else, like easy_install(1).

caller_name = eval('__name__', frame.f_globals, frame.f_locals)

__import__(caller_name)

mod = sys.modules[caller_name]

if hasattr(mod, '__file__'):

d = os.path.dirname(os.path.abspath(mod.__file__))

else:

# we're probably running setup.py as execfile("setup.py")

# (likely we're building an egg)

d = os.path.abspath('.')

# hmm, should we use sys.argv[0] like in __builtin__ case?

if parent_path is not None:

d = rel_path(d, parent_path)

return d or '.'

def njoin(*path):

"""Join two or more pathname components +

- convert a /-separated pathname to one using the OS's path separator.

- resolve `..` and `.` from path.

Either passing n arguments as in njoin('a','b'), or a sequence

of n names as in njoin(['a','b']) is handled, or a mixture of such arguments.

"""

paths = []

for p in path:

if is_sequence(p):

# njoin(['a', 'b'], 'c')

paths.append(njoin(*p))

else:

assert is_string(p)

paths.append(p)

path = paths

if not path:

# njoin()

joined = ''

else:

# njoin('a', 'b')

joined = os.path.join(*path)

if os.path.sep != '/':

joined = joined.replace('/',os.path.sep)

return minrelpath(joined)

def get_mathlibs(path=None):

"""Return the MATHLIB line from numpyconfig.h

"""

if path is not None:

config_file = os.path.join(path,'_numpyconfig.h')

else:

# Look for the file in each of the numpy include directories.

dirs = get_numpy_include_dirs()

for path in dirs:

fn = os.path.join(path,'_numpyconfig.h')

if os.path.exists(fn):

config_file = fn

break

else:

raise DistutilsError('_numpyconfig.h not found in numpy include '

'dirs %r' % (dirs,))

fid = open(config_file)

mathlibs = []

s = '#define MATHLIB'

for line in fid.readlines():

if line.startswith(s):

value = line[len(s):].strip()

if value:

mathlibs.extend(value.split(','))

fid.close()

return mathlibs

def minrelpath(path):

"""Resolve `..` and '.' from path.

"""

if not is_string(path):

return path

if '.' not in path:

return path

l = path.split(os.sep)

while l:

try:

i = l.index('.',1)

except ValueError:

break

del l[i]

j = 1

while l:

try:

i = l.index('..',j)

except ValueError:

break

if l[i-1]=='..':

j += 1

else:

del l[i],l[i-1]

j = 1

if not l:

return ''

return os.sep.join(l)

def _fix_paths(paths,local_path,include_non_existing):

assert is_sequence(paths), repr(type(paths))

new_paths = []

assert not is_string(paths),repr(paths)

for n in paths:

if is_string(n):

if '*' in n or '?' in n:

p = glob.glob(n)

p2 = glob.glob(njoin(local_path,n))

if p2:

new_paths.extend(p2)

elif p:

new_paths.extend(p)

else:

if include_non_existing:

new_paths.append(n)

print('could not resolve pattern in %r: %r' \

% (local_path,n))

else:

n2 = njoin(local_path,n)

if os.path.exists(n2):

new_paths.append(n2)

else:

if os.path.exists(n):

new_paths.append(n)

elif include_non_existing:

new_paths.append(n)

if not os.path.exists(n):

print('non-existing path in %r: %r' \

% (local_path,n))

elif is_sequence(n):

new_paths.extend(_fix_paths(n,local_path,include_non_existing))

else:

new_paths.append(n)

return [minrelpath(p) for p in new_paths]

def gpaths(paths, local_path='', include_non_existing=True):

"""Apply glob to paths and prepend local_path if needed.

"""

if is_string(paths):

paths = (paths,)

return _fix_paths(paths,local_path, include_non_existing)

_temporary_directory = None

def clean_up_temporary_directory():

from numpy.distutils import log

global _temporary_directory

if not _temporary_directory:

return

log.debug('removing %s', _temporary_directory)

try:

shutil.rmtree(_temporary_directory)

except OSError:

pass

_temporary_directory = None

def make_temp_file(suffix='', prefix='', text=True):

global _temporary_directory

if not _temporary_directory:

_temporary_directory = tempfile.mkdtemp()

atexit.register(clean_up_temporary_directory)

fid, name = tempfile.mkstemp(suffix=suffix,

prefix=prefix,

dir=_temporary_directory,

text=text)

fo = os.fdopen(fid, 'w')

return fo, name

# Hooks for colored terminal output.

# See also http://www.livinglogic.de/Python/ansistyle

def terminal_has_colors():

if sys.platform=='cygwin' and 'USE_COLOR' not in os.environ:

# Avoid importing curses that causes illegal operation

# with a message:

# PYTHON2 caused an invalid page fault in

# module CYGNURSES7.DLL as 015f:18bbfc28

# Details: Python 2.3.3 [GCC 3.3.1 (cygming special)]

# ssh to Win32 machine from debian

# curses.version is 2.2

# CYGWIN_98-4.10, release 1.5.7(0.109/3/2))

return 0

if hasattr(sys.stdout,'isatty') and sys.stdout.isatty():

try:

import curses

curses.setupterm()

if (curses.tigetnum("colors") >= 0

and curses.tigetnum("pairs") >= 0

and ((curses.tigetstr("setf") is not None

and curses.tigetstr("setb") is not None)

or (curses.tigetstr("setaf") is not None

and curses.tigetstr("setab") is not None)

or curses.tigetstr("scp") is not None)):

return 1

except Exception:

pass

return 0

if terminal_has_colors():

_colour_codes = dict(black=0, red=1, green=2, yellow=3,

blue=4, magenta=5, cyan=6, white=7, default=9)

def colour_text(s, fg=None, bg=None, bold=False):

seq = []

if bold:

seq.append('1')

if fg:

fgcode = 30 + _colour_codes.get(fg.lower(), 0)

seq.append(str(fgcode))

if bg:

bgcode = 40 + _colour_codes.get(fg.lower(), 7)

seq.append(str(bgcode))

if seq:

return '\x1b[%sm%s\x1b[0m' % (';'.join(seq), s)

else:

return s

else:

def colour_text(s, fg=None, bg=None):

return s

def default_text(s):

return colour_text(s, 'default')

def red_text(s):

return colour_text(s, 'red')

def green_text(s):

return colour_text(s, 'green')

def yellow_text(s):

return colour_text(s, 'yellow')

def cyan_text(s):

return colour_text(s, 'cyan')

def blue_text(s):

return colour_text(s, 'blue')

#########################

def cyg2win32(path):

if sys.platform=='cygwin' and path.startswith('/cygdrive'):

path = path[10] + ':' + os.path.normcase(path[11:])

return path

def mingw32():

"""Return true when using mingw32 environment.

"""

if sys.platform=='win32':

if os.environ.get('OSTYPE','')=='msys':

return True

if os.environ.get('MSYSTEM','')=='MINGW32':

return True

return False

def msvc_runtime_library():

"Return name of MSVC runtime library if Python was built with MSVC >= 7"

msc_pos = sys.version.find('MSC v.')

if msc_pos != -1:

msc_ver = sys.version[msc_pos+6:msc_pos+10]

lib = {'1300' : 'msvcr70', # MSVC 7.0

'1310' : 'msvcr71', # MSVC 7.1

'1400' : 'msvcr80', # MSVC 8

'1500' : 'msvcr90', # MSVC 9 (VS 2008)

'1600' : 'msvcr100', # MSVC 10 (aka 2010)

}.get(msc_ver, None)

else:

lib = None

return lib

def msvc_on_amd64():

if not (sys.platform=='win32' or os.name=='nt'):

return

if get_build_architecture() != 'AMD64':

return

if 'DISTUTILS_USE_SDK' in os.environ:

return

# try to avoid _MSVCCompiler__root attribute error

print('Forcing DISTUTILS_USE_SDK=1')

os.environ['DISTUTILS_USE_SDK']='1'

return

#########################

#XXX need support for .C that is also C++

cxx_ext_match = re.compile(r'.*[.](cpp|cxx|cc)\Z',re.I).match

fortran_ext_match = re.compile(r'.*[.](f90|f95|f77|for|ftn|f)\Z',re.I).match

f90_ext_match = re.compile(r'.*[.](f90|f95)\Z',re.I).match

f90_module_name_match = re.compile(r'\s*module\s*(?P<name>[\w_]+)',re.I).match

def _get_f90_modules(source):

"""Return a list of Fortran f90 module names that

given source file defines.

"""

if not f90_ext_match(source):

return []

modules = []

f = open(source,'r')

f_readlines = getattr(f,'xreadlines',f.readlines)

for line in f_readlines():

m = f90_module_name_match(line)

if m:

name = m.group('name')

modules.append(name)

# break # XXX can we assume that there is one module per file?

f.close()

return modules

def is_string(s):

return isinstance(s, str)

def all_strings(lst):

"""Return True if all items in lst are string objects. """

for item in lst:

if not is_string(item):

return False

return True

def is_sequence(seq):

if is_string(seq):

return False

try:

len(seq)

except:

return False

return True

def is_glob_pattern(s):

return is_string(s) and ('*' in s or '?' is s)

def as_list(seq):

if is_sequence(seq):

return list(seq)

else:

return [seq]

def get_language(sources):

# not used in numpy/scipy packages, use build_ext.detect_language instead

"""Determine language value (c,f77,f90) from sources """

language = None

for source in sources:

if isinstance(source, str):

if f90_ext_match(source):

language = 'f90'

break

elif fortran_ext_match(source):

language = 'f77'

return language

def has_f_sources(sources):

"""Return True if sources contains Fortran files """

for source in sources:

if fortran_ext_match(source):

return True

return False

def has_cxx_sources(sources):

"""Return True if sources contains C++ files """

for source in sources:

if cxx_ext_match(source):

return True

return False

def filter_sources(sources):

"""Return four lists of filenames containing

C, C++, Fortran, and Fortran 90 module sources,

respectively.

"""

c_sources = []

cxx_sources = []

f_sources = []

fmodule_sources = []

for source in sources:

if fortran_ext_match(source):

modules = _get_f90_modules(source)

if modules:

fmodule_sources.append(source)

else:

f_sources.append(source)

elif cxx_ext_match(source):

cxx_sources.append(source)

else:

c_sources.append(source)

return c_sources, cxx_sources, f_sources, fmodule_sources

def _get_headers(directory_list):

# get *.h files from list of directories

headers = []

for d in directory_list:

head = glob.glob(os.path.join(d,"*.h")) #XXX: *.hpp files??

headers.extend(head)

return headers

def _get_directories(list_of_sources):

# get unique directories from list of sources.

direcs = []

for f in list_of_sources:

d = os.path.split(f)

if d[0] != '' and not d[0] in direcs:

direcs.append(d[0])

return direcs

def get_dependencies(sources):

#XXX scan sources for include statements

return _get_headers(_get_directories(sources))

def is_local_src_dir(directory):

"""Return true if directory is local directory.

"""

if not is_string(directory):

return False

abs_dir = os.path.abspath(directory)

c = os.path.commonprefix([os.getcwd(),abs_dir])

new_dir = abs_dir[len(c):].split(os.sep)

if new_dir and not new_dir[0]:

new_dir = new_dir[1:]

if new_dir and new_dir[0]=='build':

return False

new_dir = os.sep.join(new_dir)

return os.path.isdir(new_dir)

def general_source_files(top_path):

pruned_directories = {'CVS':1, '.svn':1, 'build':1}

prune_file_pat = re.compile(r'(?:[~#]|\.py[co]|\.o)$')

for dirpath, dirnames, filenames in os.walk(top_path, topdown=True):

pruned = [ d for d in dirnames if d not in pruned_directories ]

dirnames[:] = pruned

for f in filenames:

if not prune_file_pat.search(f):

yield os.path.join(dirpath, f)

def general_source_directories_files(top_path):

"""Return a directory name relative to top_path and

files contained.

"""

pruned_directories = ['CVS','.svn','build']

prune_file_pat = re.compile(r'(?:[~#]|\.py[co]|\.o)$')

for dirpath, dirnames, filenames in os.walk(top_path, topdown=True):

pruned = [ d for d in dirnames if d not in pruned_directories ]

dirnames[:] = pruned

for d in dirnames:

dpath = os.path.join(dirpath, d)

rpath = rel_path(dpath, top_path)

files = []

for f in os.listdir(dpath):

fn = os.path.join(dpath,f)

if os.path.isfile(fn) and not prune_file_pat.search(fn):

files.append(fn)

yield rpath, files

dpath = top_path

rpath = rel_path(dpath, top_path)

filenames = [os.path.join(dpath,f) for f in os.listdir(dpath) \

if not prune_file_pat.search(f)]

files = [f for f in filenames if os.path.isfile(f)]

yield rpath, files

def get_ext_source_files(ext):

# Get sources and any include files in the same directory.

filenames = []

sources = filter(is_string, ext.sources)

filenames.extend(sources)

filenames.extend(get_dependencies(sources))

for d in ext.depends:

if is_local_src_dir(d):

filenames.extend(list(general_source_files(d)))

elif os.path.isfile(d):

filenames.append(d)

return filenames

def get_script_files(scripts):

scripts = filter(is_string, scripts)

return scripts

def get_lib_source_files(lib):

filenames = []

sources = lib[1].get('sources',[])

sources = filter(is_string, sources)

filenames.extend(sources)

filenames.extend(get_dependencies(sources))

depends = lib[1].get('depends',[])

for d in depends:

if is_local_src_dir(d):

filenames.extend(list(general_source_files(d)))

elif os.path.isfile(d):

filenames.append(d)

return filenames

def get_shared_lib_extension(is_python_ext=False):

"""Return the correct file extension for shared libraries.

Parameters

----------

is_python_ext : bool, optional

Whether the shared library is a Python extension. Default is False.

Returns

-------

so_ext : str

The shared library extension.

Notes

-----

For Python shared libs, `so_ext` will typically be '.so' on Linux and OS X,

and '.pyd' on Windows. For Python >= 3.2 `so_ext` has a tag prepended on

POSIX systems according to PEP 3149. For Python 3.2 this is implemented on

Linux, but not on OS X.

"""

so_ext = distutils.sysconfig.get_config_var('SO') or ''

# fix long extension for Python >=3.2, see PEP 3149.

if (not is_python_ext) and 'SOABI' in distutils.sysconfig.get_config_vars():

# Does nothing unless SOABI config var exists

so_ext = so_ext.replace('.' + distutils.sysconfig.get_config_var('SOABI'), '', 1)

return so_ext

def get_data_files(data):

if is_string(data):

return [data]

sources = data[1]

filenames = []

for s in sources:

if hasattr(s, '__call__'):

continue

if is_local_src_dir(s):

filenames.extend(list(general_source_files(s)))

elif is_string(s):

if os.path.isfile(s):

filenames.append(s)

else:

print('Not existing data file:',s)

else:

raise TypeError(repr(s))

return filenames

def dot_join(*args):

return '.'.join([a for a in args if a])

def get_frame(level=0):

"""Return frame object from call stack with given level.

"""

try:

return sys._getframe(level+1)

except AttributeError:

frame = sys.exc_info()[2].tb_frame

for _ in range(level+1):

frame = frame.f_back

return frame

class SconsInfo(object):

"""

Container object holding build info for building a package with scons.

Parameters

----------

scons_path : str or None

Path to scons script, relative to the directory of setup.py.

If None, no scons script is specified. This can be useful to add only

pre- and post-hooks to a configuration.

parent_name : str or None

Name of the parent package (for example "numpy").

pre_hook : sequence of callables or None

Callables that are executed before scons is invoked.

Each callable should be defined as ``callable(*args, **kw)``.

post_hook : sequence of callables or None

Callables that are executed after scons is invoked.

Each callable should be defined as ``callable(*args, **kw)``.

source_files : list of str or None

List of paths to source files, relative to the directory of setup.py.

pkg_path : str or None

Path to the package for which the `SconsInfo` instance holds the

build info, relative to the directory of setup.py.

Notes

-----

All parameters are available as attributes of a `SconsInfo` instance.

"""

def __init__(self, scons_path, parent_name, pre_hook,

post_hook, source_files, pkg_path):

self.scons_path = scons_path

self.parent_name = parent_name

self.pre_hook = pre_hook

self.post_hook = post_hook

self.source_files = source_files

if pkg_path:

self.pkg_path = pkg_path

else:

if scons_path:

self.pkg_path = os.path.dirname(scons_path)

else:

self.pkg_path = ''

######################

class Configuration(object):

_list_keys = ['packages', 'ext_modules', 'data_files', 'include_dirs',

'libraries', 'headers', 'scripts', 'py_modules', 'scons_data',

'installed_libraries']

_dict_keys = ['package_dir', 'installed_pkg_config']

_extra_keys = ['name', 'version']

numpy_include_dirs = []

def __init__(self,

package_name=None,

parent_name=None,

top_path=None,

package_path=None,

caller_level=1,

setup_name='setup.py',

**attrs):

"""Construct configuration instance of a package.

package_name -- name of the package

Ex.: 'distutils'

parent_name -- name of the parent package

Ex.: 'numpy'

top_path -- directory of the toplevel package

Ex.: the directory where the numpy package source sits

package_path -- directory of package. Will be computed by magic from the

directory of the caller module if not specified

Ex.: the directory where numpy.distutils is

caller_level -- frame level to caller namespace, internal parameter.

"""

self.name = dot_join(parent_name, package_name)

self.version = None

caller_frame = get_frame(caller_level)

self.local_path = get_path_from_frame(caller_frame, top_path)

# local_path -- directory of a file (usually setup.py) that

# defines a configuration() function.

# local_path -- directory of a file (usually setup.py) that

# defines a configuration() function.

if top_path is None:

top_path = self.local_path

self.local_path = ''

if package_path is None:

package_path = self.local_path

elif os.path.isdir(njoin(self.local_path,package_path)):

package_path = njoin(self.local_path,package_path)

if not os.path.isdir(package_path or '.'):

raise ValueError("%r is not a directory" % (package_path,))

self.top_path = top_path

self.package_path = package_path

# this is the relative path in the installed package

self.path_in_package = os.path.join(*self.name.split('.'))

self.list_keys = self._list_keys[:]

self.dict_keys = self._dict_keys[:]

for n in self.list_keys:

v = copy.copy(attrs.get(n, []))

setattr(self, n, as_list(v))

for n in self.dict_keys:

v = copy.copy(attrs.get(n, {}))

setattr(self, n, v)

known_keys = self.list_keys + self.dict_keys

self.extra_keys = self._extra_keys[:]

for n in attrs.keys():

if n in known_keys:

continue

a = attrs[n]

setattr(self,n,a)

if isinstance(a, list):

self.list_keys.append(n)

elif isinstance(a, dict):

self.dict_keys.append(n)

else:

self.extra_keys.append(n)

if os.path.exists(njoin(package_path,'__init__.py')):

self.packages.append(self.name)

self.package_dir[self.name] = package_path

self.options = dict(

ignore_setup_xxx_py = False,

assume_default_configuration = False,

delegate_options_to_subpackages = False,

quiet = False,

)

caller_instance = None

for i in range(1,3):

try:

f = get_frame(i)

except ValueError:

break

try:

caller_instance = eval('self',f.f_globals,f.f_locals)

break

except NameError:

pass

if isinstance(caller_instance, self.__class__):

if caller_instance.options['delegate_options_to_subpackages']:

self.set_options(**caller_instance.options)

self.setup_name = setup_name

def todict(self):

"""

Return a dictionary compatible with the keyword arguments of distutils

setup function.

Examples

--------

>>> setup(**config.todict()) #doctest: +SKIP

"""

self._optimize_data_files()

d = {}

known_keys = self.list_keys + self.dict_keys + self.extra_keys

for n in known_keys:

a = getattr(self,n)

if a:

d[n] = a

return d

def info(self, message):

if not self.options['quiet']:

print(message)

def warn(self, message):

sys.stderr.write('Warning: %s' % (message,))

def set_options(self, **options):

"""

Configure Configuration instance.

The following options are available:

- ignore_setup_xxx_py

- assume_default_configuration

- delegate_options_to_subpackages

- quiet

"""

for key, value in options.items():

if key in self.options:

self.options[key] = value

else:

raise ValueError('Unknown option: '+key)

def get_distribution(self):

"""Return the distutils distribution object for self."""

from numpy.distutils.core import get_distribution

return get_distribution()

def _wildcard_get_subpackage(self, subpackage_name,

parent_name,

caller_level = 1):

l = subpackage_name.split('.')

subpackage_path = njoin([self.local_path]+l)

dirs = filter(os.path.isdir,glob.glob(subpackage_path))

config_list = []

for d in dirs:

if not os.path.isfile(njoin(d,'__init__.py')):

continue

if 'build' in d.split(os.sep):

continue

n = '.'.join(d.split(os.sep)[-len(l):])

c = self.get_subpackage(n,

parent_name = parent_name,

caller_level = caller_level+1)

config_list.extend(c)

return config_list

def _get_configuration_from_setup_py(self, setup_py,

subpackage_name,

subpackage_path,

parent_name,

caller_level = 1):

# In case setup_py imports local modules:

sys.path.insert(0,os.path.dirname(setup_py))

try:

fo_setup_py = open(setup_py, 'U')

setup_name = os.path.splitext(os.path.basename(setup_py))[0]

n = dot_join(self.name,subpackage_name,setup_name)

setup_module = imp.load_module('_'.join(n.split('.')),

fo_setup_py,

setup_py,

('.py', 'U', 1))

fo_setup_py.close()

if not hasattr(setup_module,'configuration'):

if not self.options['assume_default_configuration']:

self.warn('Assuming default configuration '\

'(%s does not define configuration())'\

% (setup_module))

config = Configuration(subpackage_name, parent_name,

self.top_path, subpackage_path,

caller_level = caller_level + 1)

else:

pn = dot_join(*([parent_name] + subpackage_name.split('.')[:-1]))

args = (pn,)

def fix_args_py2(args):

if setup_module.configuration.func_code.co_argcount > 1:

args = args + (self.top_path,)

return args

def fix_args_py3(args):

if setup_module.configuration.__code__.co_argcount > 1:

args = args + (self.top_path,)

return args

if sys.version_info[0] < 3:

args = fix_args_py2(args)

else:

args = fix_args_py3(args)

config = setup_module.configuration(*args)

if config.name!=dot_join(parent_name,subpackage_name):

self.warn('Subpackage %r configuration returned as %r' % \

(dot_join(parent_name,subpackage_name), config.name))

finally:

del sys.path[0]

return config

def get_subpackage(self,subpackage_name,

subpackage_path=None,

parent_name=None,

caller_level = 1):

"""Return list of subpackage configurations.

Parameters

----------

subpackage_name: str,None

Name of the subpackage to get the configuration. '*' in

subpackage_name is handled as a wildcard.

subpackage_path: str

If None, then the path is assumed to be the local path plus the

subpackage_name. If a setup.py file is not found in the

subpackage_path, then a default configuration is used.

parent_name: str

Parent name.

"""

if subpackage_name is None:

if subpackage_path is None:

raise ValueError(

"either subpackage_name or subpackage_path must be specified")

subpackage_name = os.path.basename(subpackage_path)

# handle wildcards

l = subpackage_name.split('.')

if subpackage_path is None and '*' in subpackage_name:

return self._wildcard_get_subpackage(subpackage_name,

parent_name,

caller_level = caller_level+1)

assert '*' not in subpackage_name,repr((subpackage_name, subpackage_path,parent_name))

if subpackage_path is None:

subpackage_path = njoin([self.local_path] + l)

else:

subpackage_path = njoin([subpackage_path] + l[:-1])

subpackage_path = self.paths([subpackage_path])[0]

setup_py = njoin(subpackage_path, self.setup_name)

if not self.options['ignore_setup_xxx_py']:

if not os.path.isfile(setup_py):

setup_py = njoin(subpackage_path,

'setup_%s.py' % (subpackage_name))

if not os.path.isfile(setup_py):

if not self.options['assume_default_configuration']:

self.warn('Assuming default configuration '\

'(%s/{setup_%s,setup}.py was not found)' \

% (os.path.dirname(setup_py), subpackage_name))

config = Configuration(subpackage_name, parent_name,

self.top_path, subpackage_path,

caller_level = caller_level+1)

else:

config = self._get_configuration_from_setup_py(

setup_py,

subpackage_name,

subpackage_path,

parent_name,

caller_level = caller_level + 1)

if config:

return [config]

else:

return []

def add_subpackage(self,subpackage_name,

subpackage_path=None,

standalone = False):

"""Add a sub-package to the current Configuration instance.

This is useful in a setup.py script for adding sub-packages to a

package.

Parameters

----------

subpackage_name: str

name of the subpackage

subpackage_path: str

if given, the subpackage path such as the subpackage is in

subpackage_path / subpackage_name. If None,the subpackage is

assumed to be located in the local path / subpackage_name.

standalone: bool

"""

if standalone:

parent_name = None

else:

parent_name = self.name