return (

os.path.isdir(path) and

os.path.isfile(os.path.join(path, '__init__.py'))

packages = [root_package]

root_count = len(root_path.split('/'))

for (dir_path, dir_names, file_names) in os.walk(convert_path(root_path)):

# Prune dir_names *in-place* to prevent unwanted directory recursion

for dir_name in list(dir_names):

if not os.path.isfile(os.path.join(dir_path, dir_name, '__init__.py')):

dir_names.remove(dir_name)

if dir_name in exclude_dirs:

dir_names.remove(dir_name)

if dir_names:

prefix = dir_path.split('/')[root_count:]

packages.extend(['.'.join([root_package] + prefix + [dir_name]) for dir_name in dir_names])

"""Returns a generator of files from the top of the tree. Removing the given prefix from the root/file result."""

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

if '.svn' in dirs:

dirs.remove('.svn')

for file in files:

"""Run the Iris tests under nose and multiprocessor for performance"""

description = "run tests under nose and multiprocessor for performance"

user_options = [

('no-data', 'n', 'Override the paths to the data repositorys so it appears to the tests that it does not exist.'),

('system-tests', 's', 'Run only the limited subset of system tests.')

]

boolean_options = [

'no-data',

'system-tests'

]

def initialize_options(self):

self.no_data = False

self.system_tests = False

def finalize_options(self):

if self.no_data:

print "Running tests in no-data mode..."

# This enviroment variable will be propagated to all the processes that

# nose.run creates allowing us to simluate the absence of test data

os.environ["override_data_repository"] = "true"

if self.system_tests:

print "Running only system tests..."

def run(self):

if self.distribution.tests_require:

self.distribution.fetch_build_eggs(self.distribution.tests_require)

script_path = sys.path[0]

tests = []

lib_dir = os.path.join(script_path, 'lib')

for mod in os.listdir(lib_dir):

path = os.path.join(lib_dir, mod)

if mod != '.svn' and os.path.exists(os.path.join(path, 'tests')):

tests.append('%s.tests' % mod)

if not tests:

raise CommandError('No tests found in %s/*/tests' % lib_dir)

if self.system_tests:

regexp_pat = r'--match=^[Ss]ystem'

else:

regexp_pat = r'--match=^([Tt]est(?![Mm]ixin)|[Ss]ystem)'

n_processors = max(multiprocessing.cpu_count() - 1, 1)

for test in tests:

print

print 'Running test discovery on %s with %s processors.' % (test, n_processors)

# run the tests at module level i.e. my_module.tests

# - test must start with test/Test and must not contain the word Mixin.

nose.run(argv=['', test, '--processes=%s' % n_processors,

'--verbosity=2', regexp_pat,

script_path = os.path.join('tools', 'generate_std_names.py')

xml_path = os.path.join('etc', 'cf-standard-name-table.xml')

module_path = os.path.join(target_dir, 'iris', 'std_names.py')

cmd = (sys.executable, script_path, xml_path, module_path)

description = "generate CF standard name module"

user_options = []

def initialize_options(self):

pass

def finalize_options(self):

pass

def run(self):

cmd = std_name_cmd('lib')

"""

Adds the creation of the CF standard names module to the standard

"build_py" command.

"""

def run(self):

# Run the main build command first to make sure all the target

# directories are in place.

build_py.build_py.run(self)

# Now build the std_names module.

cmd = std_name_cmd(self.build_lib)

"""Runs after a standard "build_ext" to compile the PyKE rules."""

def run(self):

# Call parent

build_ext.build_ext.run(self)

# Add our new build dir to the start of the path to pick up the KE rules

sys.path.insert(0, self.build_lib)

# Compile the pyke rules

from pyke import knowledge_engine

import iris.fileformats._pyke_rules