def _show_help (self, parser, global_options=1, display_options=1, commands=[]): "Join individual messages after default help" _Distribution._show_help(self, parser, global_options, display_options, commands) # display additions for command_class in self.cmdclass.values(): if hasattr(command_class, 'show_after_help'): command_class.show_after_help(commands) # must be staticmethod
def test_find_config_files_disable(self): # Ticket #1180: Allow user to disable their home config file. temp_home = self.mkdtemp() if os.name == 'posix': user_filename = os.path.join(temp_home, ".pydistutils.cfg") else: user_filename = os.path.join(temp_home, "pydistutils.cfg") with open(user_filename, 'w') as f: f.write('[distutils]\n') def _expander(path): return temp_home old_expander = os.path.expanduser os.path.expanduser = _expander try: d = Distribution() all_files = d.find_config_files() d = Distribution(attrs={'script_args': ['--no-user-cfg']}) files = d.find_config_files() finally: os.path.expanduser = old_expander # make sure --no-user-cfg disables the user cfg file self.assertEqual(len(all_files)-1, len(files))
def pyx_to_dll(filename, ext = None, force_rebuild = 0): """Compile a PYX file to a DLL and return the name of the generated .so or .dll .""" assert os.path.exists(filename) path, name = os.path.split(filename) if not ext: modname, extension = os.path.splitext(name) assert extension == ".pyx", extension ext = Extension(name=modname, sources=[filename]) if DEBUG: quiet = "--verbose" else: quiet = "--quiet" args = [quiet, "build_ext"] if force_rebuild: args.append("--force") dist = Distribution({"script_name": None, "script_args": args}) if not dist.ext_modules: dist.ext_modules = [] dist.ext_modules.append(ext) dist.cmdclass = {'build_ext': build_ext} build = dist.get_command_obj('build') build.build_base = os.path.join(path, "_pyxbld") try: ok = dist.parse_command_line() except DistutilsArgError, msg: raise
def compile_so_file(): from distutils.dist import Distribution from distutils.extension import Extension from distutils.ccompiler import get_default_compiler udir = py.test.ensuretemp('_ctypes_test') cfile = py.magic.autopath().dirpath().join("_ctypes_test.c") saved_environ = os.environ.items() olddir = udir.chdir() try: attrs = { 'name': "_ctypes_test", 'ext_modules': [ Extension("_ctypes_test", [str(cfile)]), ], 'script_name': 'setup.py', 'script_args': ['-q', 'build_ext', '--inplace'], } dist = Distribution(attrs) if not dist.parse_command_line(): raise ValueError, "distutils cmdline parse error" dist.run_commands() finally: olddir.chdir() for key, value in saved_environ: if os.environ.get(key) != value: os.environ[key] = value if sys.platform == 'win32': so_ext = '.dll' else: so_ext = '.so' return udir.join('_ctypes_test' + so_ext)
def get_dummy_distribution(): """ Returns a distutils Distribution object used to instrument the setup environment before calling the actual setup() function. """ from .setup_helpers import _module_state if _module_state['registered_commands'] is None: raise RuntimeError( 'astropy_helpers.setup_helpers.register_commands() must be ' 'called before using ' 'astropy_helpers.setup_helpers.get_dummy_distribution()') # 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': sys.argv[1:]}) dist.cmdclass.update(_module_state['registered_commands']) with silence(): try: dist.parse_config_files() dist.parse_command_line() except (DistutilsError, AttributeError, SystemExit): # Let distutils handle DistutilsErrors itself AttributeErrors can # get raise for ./setup.py --help SystemExit can be raised if a # display option was used, for example pass return dist
def runTest(self): import nose.commands from setuptools import Command from distutils.dist import Distribution from nose.config import Config, user_config_files from nose.plugins import PluginManager class DummyNose(Command): description = "Dummy" manager = PluginManager() manager.plugins = [RandomlyPlugin()] __config = Config( files=user_config_files(), plugins=manager) __parser = __config.getParser() user_options = nose.commands.get_user_options(__parser) def initialize_options(self): pass def finalize_options(self): pass def run(self): pass dist = Distribution({'cmdclass': {'nosetests': DummyNose}}) dist.script_args = ['nosetests'] # This test should merely not throw an exception dist.parse_command_line()
def distutils_scheme(dist_name, user=False, home=None, root=None): """ Return a distutils install scheme """ from distutils.dist import Distribution scheme = {} d = Distribution({'name': dist_name}) d.parse_config_files() i = d.get_command_obj('install', create=True) # NOTE: setting user or home has the side-effect of creating the home dir or # user base for installations during finalize_options() # ideally, we'd prefer a scheme class that has no side-effects. i.user = user or i.user i.home = home or i.home i.root = root or i.root i.finalize_options() for key in SCHEME_KEYS: scheme[key] = getattr(i, 'install_'+key) if running_under_virtualenv(): scheme['headers'] = os.path.join(sys.prefix, 'include', 'site', 'python' + sys.version[:3], dist_name) if root is not None: scheme["headers"] = os.path.join( root, os.path.abspath(scheme["headers"])[1:], ) return scheme
def package_install_site(name='', user=False, plat_specific=False): """pip-inspired, distutils-based method for fetching the default install location (site-packages path). Returns virtual environment or system site-packages, unless `user=True` in which case returns user-site (typ. under `~/.local/ on linux). If there's a distinction (on a particular system) between platform specific and pure python package locations, set `plat_specific=True` to retrieve the former. """ dist = Distribution({'name': name}) dist.parse_config_files() inst = dist.get_command_obj('install', create=True) # NOTE: specifying user=True will create user-site if user: inst.user = user inst.prefix = "" inst.finalize_options() # platform-specific site vs. purelib (platform-independent) site if plat_specific: loc = inst.install_platlib else: loc = inst.install_purelib # install_lib specified in setup.cfg has highest precedence if 'install_lib' in dist.get_option_dict('install'): loc = inst.install_lib return loc
def test_custom_pydistutils(self): # fixes #2166 # make sure pydistutils.cfg is found if os.name == "posix": user_filename = ".pydistutils.cfg" else: user_filename = "pydistutils.cfg" temp_dir = self.mkdtemp() user_filename = os.path.join(temp_dir, user_filename) f = open(user_filename, "w") try: f.write(".") finally: f.close() try: dist = Distribution() # linux-style if sys.platform in ("linux", "darwin"): os.environ["HOME"] = temp_dir files = dist.find_config_files() self.assertIn(user_filename, files) # win32-style if sys.platform == "win32": # home drive should be found os.environ["HOME"] = temp_dir files = dist.find_config_files() self.assertIn(user_filename, files, "%r not found in %r" % (user_filename, files)) finally: os.remove(user_filename)
def test_custom_pydistutils(self): # fixes #2166 # make sure pydistutils.cfg is found if os.name == 'posix': user_filename = ".pydistutils.cfg" else: user_filename = "pydistutils.cfg" temp_dir = self.mkdtemp() user_filename = os.path.join(temp_dir, user_filename) f = open(user_filename, 'w') try: f.write('.') finally: f.close() try: dist = Distribution() # linux-style if sys.platform in ('linux', 'darwin'): os.environ['HOME'] = temp_dir files = dist.find_config_files() self.assertIn(user_filename, files) # win32-style if sys.platform == 'win32': # home drive should be found os.environ['HOME'] = temp_dir files = dist.find_config_files() self.assertIn(user_filename, files, '%r not found in %r' % (user_filename, files)) finally: os.remove(user_filename)
def get_include(user=False): from distutils.dist import Distribution import os import sys # Are we running in a virtual environment? virtualenv = hasattr(sys, 'real_prefix') or \ sys.prefix != getattr(sys, "base_prefix", sys.prefix) if virtualenv: return os.path.join(sys.prefix, 'include', 'site', 'python' + sys.version[:3]) else: dist = Distribution({'name': 'pybind11'}) dist.parse_config_files() dist_cobj = dist.get_command_obj('install', create=True) # Search for packages in user's home directory? if user: dist_cobj.user = user dist_cobj.prefix = "" dist_cobj.finalize_options() return os.path.dirname(dist_cobj.install_headers)
def __init__(self, attrs): self.po = None self.appdata = None self.appmodules = None self.links = None self.configurable = None Distribution.__init__(self, attrs)
def distutils_scheme(dist_name, user=False, home=None, root=None, isolated=False, prefix=None): """ Return a distutils install scheme """ from distutils.dist import Distribution scheme = {} if isolated: extra_dist_args = {"script_args": ["--no-user-cfg"]} else: extra_dist_args = {} dist_args = {'name': dist_name} dist_args.update(extra_dist_args) d = Distribution(dist_args) d.parse_config_files() i = d.get_command_obj('install', create=True) # NOTE: setting user or home has the side-effect of creating the home dir # or user base for installations during finalize_options() # ideally, we'd prefer a scheme class that has no side-effects. assert not (user and prefix), "user={0} prefix={1}".format(user, prefix) i.user = user or i.user if user: i.prefix = "" i.prefix = prefix or i.prefix i.home = home or i.home i.root = root or i.root i.finalize_options() for key in SCHEME_KEYS: scheme[key] = getattr(i, 'install_' + key) # install_lib specified in setup.cfg should install *everything* # into there (i.e. it takes precedence over both purelib and # platlib). Note, i.install_lib is *always* set after # finalize_options(); we only want to override here if the user # has explicitly requested it hence going back to the config if 'install_lib' in d.get_option_dict('install'): scheme.update(dict(purelib=i.install_lib, platlib=i.install_lib)) if running_under_virtualenv(): scheme['headers'] = os.path.join( sys.prefix, 'include', 'site', 'python' + sys.version[:3], dist_name, ) if root is not None: path_no_drive = os.path.splitdrive( os.path.abspath(scheme["headers"]))[1] scheme["headers"] = os.path.join( root, path_no_drive[1:], ) return scheme
def __init__(self, attrs): try: os.remove("prewikka/siteconfig.py") except: pass self.conf_files = [ ] Distribution.__init__(self, attrs)
def test_classifier(self): attrs = {'name': 'Boa', 'version': '3.0', 'classifiers': ['Programming Language :: Python :: 3']} dist = Distribution(attrs) self.assertEqual(dist.get_classifiers(), ['Programming Language :: Python :: 3']) meta = self.format_metadata(dist) self.assertIn('Metadata-Version: 1.1', meta)
def test_finalize_options(self): attrs = {"keywords": "one,two", "platforms": "one,two"} dist = Distribution(attrs=attrs) dist.finalize_options() # finalize_option splits platforms and keywords self.assertEqual(dist.metadata.platforms, ["one", "two"]) self.assertEqual(dist.metadata.keywords, ["one", "two"])
def test_provides(self): attrs = {"name": "package", "version": "1.0", "provides": ["package", "package.sub"]} dist = Distribution(attrs) self.assertEqual(dist.metadata.get_provides(), ["package", "package.sub"]) self.assertEqual(dist.get_provides(), ["package", "package.sub"]) meta = self.format_metadata(dist) self.assertIn("Metadata-Version: 1.1", meta) self.assertNotIn("requires:", meta.lower()) self.assertNotIn("obsoletes:", meta.lower())
def test_show_help(self): dist = Distribution() sys.argv = [] dist.help = 1 dist.script_name = 'setup.py' with captured_stdout() as s: dist.parse_command_line() output = [ line for line in s.getvalue().split('\n') if line.strip() != '' ] self.assertTrue(output)
def __init__(self, attrs): self.cflags = None # Default CFLAGS overridable by setup.cfg self.ldflags = None # Default LDFLAGS overridable by setup.cfg self.ext_options = None Distribution.__init__(self, attrs) self.cmdclass['build_py'] = build_py self.cmdclass['build_ext'] = build_ext self.cmdclass['test'] = test self.modules_to_cythonize = set()
def __init__(self, attrs): try: os.remove("prewikka/siteconfig.py") except: pass self.conf_files = [ ] self.closed_source = os.path.exists("PKG-INFO") Distribution.__init__(self, attrs)
def __init__(self, attrs=None): Distribution.__init__(self, attrs) self.cmdclass = { 'config': config, 'build_ext': build_ext, 'sdist': sdist, 'docs': sphinx_build, 'clean': clean, }
def handle_makemessages(self, **options): locale_paths = list(settings.LOCALE_PATHS) domain = options.pop('domain') locales = options.pop('locale') # support for mapping file specification via setup.cfg # TODO: Try to support all possible options. distribution = Distribution() distribution.parse_config_files(distribution.find_config_files()) mapping_file = options.pop('mapping_file', None) has_extract = 'extract_messages' in distribution.command_options if mapping_file is None and has_extract: opts = distribution.command_options['extract_messages'] try: mapping_file = opts['mapping_file'][1] except (IndexError, KeyError): mapping_file = None for path in locale_paths: potfile = os.path.join(path, '%s.pot' % domain) if not os.path.exists(path): os.makedirs(path) if not os.path.exists(potfile): with open(potfile, 'wb') as fobj: fobj.write(b'') cmd = ['pybabel', 'extract', '-o', potfile] if mapping_file is not None: cmd.extend(['-F', mapping_file]) cmd.append(os.path.dirname(os.path.relpath(path))) call(cmd) for locale in locales: pofile = os.path.join( os.path.dirname(potfile), locale, 'LC_MESSAGES', '%s.po' % domain) if not os.path.isdir(os.path.dirname(pofile)): os.makedirs(os.path.dirname(pofile)) if not os.path.exists(pofile): with open(pofile, 'wb') as fobj: fobj.write(b'') cmd = ['pybabel', 'update', '-D', domain, '-i', potfile, '-d', os.path.relpath(path), '-l', locale] call(cmd)
def __init__(self, attrs = None): #It's important to define opotions before to call __init__ #otherwise AttributeError: UsageDistribution instance has no attribute 'conf_files' self.conf_files = None self.doc_files = None self.fix_prefix = None self.fix_conf = None Distribution.__init__(self, attrs = attrs) self.common_usage = """\
def test_get_command_packages(self): dist = Distribution() self.assertEqual(dist.command_packages, None) cmds = dist.get_command_packages() self.assertEqual(cmds, ["distutils.command"]) self.assertEqual(dist.command_packages, ["distutils.command"]) dist.command_packages = "one,two" cmds = dist.get_command_packages() self.assertEqual(cmds, ["distutils.command", "one", "two"])
def test_get_command_packages(self): dist = Distribution() self.assertEqual(dist.command_packages, None) cmds = dist.get_command_packages() self.assertEqual(cmds, ['distutils.command']) self.assertEqual(dist.command_packages, ['distutils.command']) dist.command_packages = 'one,two' cmds = dist.get_command_packages() self.assertEqual(cmds, ['distutils.command', 'one', 'two']) return
def test_finalize_options(self): attrs = {'keywords': 'one,two', 'platforms': 'one,two'} dist = Distribution(attrs=attrs) dist.finalize_options() # finalize_option splits platforms and keywords self.assertEqual(dist.metadata.platforms, ['one', 'two']) self.assertEqual(dist.metadata.keywords, ['one', 'two'])
def test_show_help(self): # smoke test, just makes sure some help is displayed dist = Distribution() sys.argv = [] dist.help = 1 dist.script_name = "setup.py" with captured_stdout() as s: dist.parse_command_line() output = [line for line in s.getvalue().split("\n") if line.strip() != ""] self.assertTrue(output)
def __init__(self, attrs=None): if sys.platform == "win32": self.executables = [] self.mandir = "share/man" self.with_aeidon = True self.with_gaupol = True self.with_iso_codes = True distribution.__init__(self, attrs) self.data_files = [] self.packages = [] self.scripts = []
def compiler_type(): """ Gets the compiler type from distutils. On Windows with MSVC it will be "msvc". On OS X and linux it is "unix". """ dist = Distribution() dist.parse_config_files() cmd = dist.get_command_obj('build') cmd.ensure_finalized() compiler = new_compiler(compiler=cmd.compiler) return compiler.compiler_type
def test_initialize(self): # we don't use the dist from setUp because # we want to test before finalize is called dist = Distribution(attrs=self.attrs) bdist = dist.get_command_obj('bdist_prestoadmin') self.assertEquals(bdist.bdist_dir, None) self.assertEquals(bdist.dist_dir, None) self.assertEquals(bdist.virtualenv_version, None) self.assertEquals(bdist.keep_temp, False) self.assertEquals(bdist.online_install, False)
def compile_c_module(cfiles, modbasename, eci, tmpdir=None): #try: # from distutils.log import set_threshold # set_threshold(10000) #except ImportError: # print "ERROR IMPORTING" # pass cfiles = [py.path.local(f) for f in cfiles] if tmpdir is None: tmpdir = udir.join("module_cache").ensure(dir=1) num = 0 cfiles += eci.separate_module_files include_dirs = list(eci.include_dirs) include_dirs.append(py.path.local(pypydir).join('translator', 'c')) library_dirs = list(eci.library_dirs) if sys.platform == 'darwin': # support Fink & Darwinports for s in ('/sw/', '/opt/local/'): if s + 'include' not in include_dirs and \ os.path.exists(s + 'include'): include_dirs.append(s + 'include') if s + 'lib' not in library_dirs and \ os.path.exists(s + 'lib'): library_dirs.append(s + 'lib') num = 0 modname = modbasename while 1: if not tmpdir.join(modname + so_ext).check(): break num += 1 modname = '%s_%d' % (modbasename, num) lastdir = tmpdir.chdir() libraries = eci.libraries ensure_correct_math() try: if debug: print "modname", modname c = stdoutcapture.Capture(mixed_out_err=True) try: try: if compiler_command(): # GCC-ish options only from distutils import sysconfig gcv = sysconfig.get_config_vars() cmd = compiler_command().replace('%s', str(tmpdir.join(modname))) for dir in [gcv['INCLUDEPY']] + list(include_dirs): cmd += ' -I%s' % dir for dir in library_dirs: cmd += ' -L%s' % dir os.system(cmd) else: from distutils.dist import Distribution from distutils.extension import Extension from distutils.ccompiler import get_default_compiler saved_environ = os.environ.items() try: # distutils.core.setup() is really meant for end-user # interactive usage, because it eats most exceptions and # turn them into SystemExits. Instead, we directly # instantiate a Distribution, which also allows us to # ignore unwanted features like config files. extra_compile_args = [] # ensure correct math on windows if sys.platform == 'win32': extra_compile_args.append( '/Op') # get extra precision if get_default_compiler() == 'unix': old_version = False try: g = os.popen('gcc --version', 'r') verinfo = g.read() g.close() except (OSError, IOError): pass else: old_version = verinfo.startswith('2') if not old_version: extra_compile_args.extend([ "-Wno-unused-label", "-Wno-unused-variable" ]) attrs = { 'name': "testmodule", 'ext_modules': [ Extension( modname, [str(cfile) for cfile in cfiles], include_dirs=include_dirs, library_dirs=library_dirs, extra_compile_args=extra_compile_args, libraries=list(libraries), ) ], 'script_name': 'setup.py', 'script_args': ['-q', 'build_ext', '--inplace', '--force'], } dist = Distribution(attrs) if not dist.parse_command_line(): raise ValueError, "distutils cmdline parse error" dist.run_commands() finally: for key, value in saved_environ: if os.environ.get(key) != value: os.environ[key] = value finally: foutput, foutput = c.done() data = foutput.read() if data: fdump = open("%s.errors" % modname, "w") fdump.write(data) fdump.close() # XXX do we need to do some check on fout/ferr? # XXX not a nice way to import a module except: print >> sys.stderr, data raise finally: lastdir.chdir() return str(tmpdir.join(modname) + so_ext)
def test_download_url(self): attrs = {'name': 'Boa', 'version': '3.0', 'download_url': 'http://example.org/boa'} dist = Distribution(attrs) meta = self.format_metadata(dist) self.assertIn('Metadata-Version: 1.1', meta)
>>> bc = _pylibmc.client([test_server], binary=True) >>> bc.set("\0\0", "ORMOD") True >>> bc.get_multi(["\0\0"]) {'\x00\x00': 'ORMOD'} """ # Used to test pickling. class Foo(object): pass # Fix up sys.path so as to include the correct build/lib.*/ directory. import sys from distutils.dist import Distribution from distutils.command.build import build build_cmd = build(Distribution({"ext_modules": True})) build_cmd.finalize_options() lib_dirn = build_cmd.build_lib sys.path.insert(0, lib_dirn) import pylibmc, _pylibmc import socket __doc__ = pylibmc.__doc__ + "\n\n" + __doc__ # {{{ Ported cmemcache tests import unittest class TestCmemcached(unittest.TestCase): def setUp(self): self.mc = pylibmc.Client(["%s:%d" % (test_server[1:])])
'blasext.o', 'brent.o', 'comutil.o', 'misc.o', 'mnbrak.o', 'flxcomp.o', 'flxdriv.o', 'flxread.o', 'flxwrit.o', 'grdcomp.o', 'grddriv.o', 'grdinit.o', 'grdread.o', 'grdwrit.o', 'daspk.o', 'nksol.o', 'svrut1.o', 'svrut2.o', 'svrut3.o', 'svrut4.o', 'vodpk.o', 'uoa.o', 'dsum.o', 'dummy_py.o', 'error.o', 'getmsg.o', 'ssum.o', 'daux1.o', 'wdf.o' ] if petsc: uedgeobjects = uedgeobjects + ['petsc-uedge.o', 'petscMod.o'] if parallel: # add extra dot o's needed if we're parallel uedgeobjects = uedgeobjects + [] else: dummydist = Distribution() dummydist.parse_command_line() dummybuild = dummydist.get_command_obj('build') dummybuild.finalize_options() builddir = dummybuild.build_temp uedgeobjects = map(lambda p: os.path.join(builddir, p), uedgeobjects) if os.getenv('PACT_DIR') != None: library_dirs = fcompiler.libdirs + [ os.path.join(os.getenv('PACT_DIR'), 'lib') ] libraries = ['pdb', 'pml', 'score', 'blas', 'm'] + fcompiler.libs else: library_dirs = fcompiler.libdirs libraries = fcompiler.libs
def __init__(self, attrs=None): OldDistribution.__init__(self, attrs)
def test_announce(self): dist = Distribution() args = ('ok', ) kwargs = {'level': 'ok2'} self.assertRaises(ValueError, dist.announce, args, kwargs)
def distutils_scheme(dist_name, user=False, home=None, root=None, isolated=False, prefix=None): """ Return a distutils install scheme """ from distutils.dist import Distribution scheme = {} if isolated: extra_dist_args = {"script_args": ["--no-user-cfg"]} else: extra_dist_args = {} dist_args = {'name': dist_name} dist_args.update(extra_dist_args) d = Distribution(dist_args) d.parse_config_files() i = d.get_command_obj('install', create=True) # NOTE: setting user or home has the side-effect of creating the home dir # or user base.css for installations during finalize_options() # ideally, we'd prefer a scheme class that has no side-effects. assert not (user and prefix), "user={} prefix={}".format(user, prefix) i.user = user or i.user if user: i.prefix = "" i.prefix = prefix or i.prefix i.home = home or i.home i.root = root or i.root i.finalize_options() for key in SCHEME_KEYS: scheme[key] = getattr(i, 'install_' + key) # install_lib specified in setup.cfg should install *everything* # into there (i.e. it takes precedence over both purelib and # platlib). Note, i.install_lib is *always* set after # finalize_options(); we only want to override here if the user # has explicitly requested it hence going back to the config if 'install_lib' in d.get_option_dict('install'): scheme.update(dict(purelib=i.install_lib, platlib=i.install_lib)) if running_under_virtualenv(): scheme['headers'] = os.path.join( sys.prefix, 'include', 'site', 'python' + sys.version[:3], dist_name, ) if root is not None: path_no_drive = os.path.splitdrive( os.path.abspath(scheme["headers"]))[1] scheme["headers"] = os.path.join( root, path_no_drive[1:], ) return scheme
def __init__(self, *args, **kwargs): self.configure_files = [] self.configure_values = {} self.man_pages = [] _Distribution.__init__(self, *args, **kwargs)
def _build_impl(self): dist = Distribution({ "script_name": None, "script_args": ["build_ext"] }) dist.ext_modules = cythonize([self.extension]) dist.include_dirs = [] dist.cmdclass = {'build_ext': custom_build_ext} build = dist.get_command_obj('build') # following the convention of cython's pyxbuild and naming # base directory "_pyxbld" build.build_base = join(self.CYMJ_DIR_PATH, 'generated', '_pyxbld_%s' % (self.version)) dist.parse_command_line() obj_build_ext = dist.get_command_obj("build_ext") dist.run_commands() built_so_file_path, = obj_build_ext.get_outputs() return built_so_file_path
def __init__(self, attrs=None): self.add_prefix = False self.remove_prefix = False Distribution.__init__(self, attrs)
def test_pyscaffold_keyword(): dist = Distribution() integration.pyscaffold_keyword(dist, "use_pyscaffold", True)
def generate_man_page(request): path = 'build/tests-workspace/manpage_' + request.node.name command = GenerateManPage(Distribution()) setattr(command, 'output', path) command.run() return open(path).read()
def _build_extension_module(self, buildable): """ Build an extension module from the sources. """ project = self.project set_threshold(INFO if project.verbose else ERROR) distribution = Distribution() module_builder = ExtensionCommand(distribution, buildable) module_builder.build_lib = buildable.build_dir module_builder.debug = buildable.debug if buildable.debug: # Enable assert(). module_builder.undef = 'NDEBUG' module_builder.ensure_finalized() # Convert the #defines. define_macros = [] for macro in buildable.define_macros: parts = macro.split('=', maxsplit=1) name = parts[0] try: value = parts[1] except IndexError: value = None define_macros.append((name, value)) buildable.make_names_relative() module_builder.extensions = [ Extension(buildable.fq_name, buildable.sources, define_macros=define_macros, include_dirs=buildable.include_dirs, libraries=buildable.libraries, library_dirs=buildable.library_dirs) ] project.progress("Compiling the '{0}' module".format( buildable.fq_name)) saved_cwd = os.getcwd() os.chdir(buildable.build_dir) try: module_builder.run() except Exception as e: raise UserException("Unable to compile the '{0}' module".format( buildable.fq_name), detail=str(e)) # Add the extension module to the buildable's list of installables. installable = Installable('module', target_subdir=buildable.get_install_subdir()) installable.files.append( module_builder.get_ext_fullpath(buildable.fq_name)) buildable.installables.append(installable) os.chdir(saved_cwd)
import sys, os from distutils.dist import Distribution from distutils.command.install import install cmd = install(Distribution()) cmd.ensure_finalized() path = cmd.install_lib if "VIRTUAL_ENV" in os.environ: path = os.path.relpath(path, os.environ["VIRTUAL_ENV"]) sys.stdout.write(path)
def __init__(self,attrs): self.interpreters = None Distribution.__init__(self,attrs)
def setUp(self): dist = Distribution() self.cmd = MyCmd(dist)
def test_finalize_options(self): attrs = {'keywords': 'one,two', 'platforms': 'one,two'} dist = Distribution(attrs=attrs) dist.finalize_options() self.assertEqual(dist.metadata.platforms, ['one', 'two']) self.assertEqual(dist.metadata.keywords, ['one', 'two'])
def __init__(self, attrs=None): Distribution.__init__(self, attrs) self.ext_modules = []
def get_command_packages(self): pkgs = _Distribution.get_command_packages(self) if "freddist.command" not in self.command_packages: pkgs.insert(0, "freddist.command") self.command_packages = pkgs return pkgs
def __init__(self, attrs=None): self.coredata_files = None self.example_files = None self.document_files = None Distribution.__init__(self, attrs)
def __init__(self, *args): self.without_gettext = False Distribution.__init__(self, *args)
def has_ext_modules(self): # self.ext_modules is emptied in hgbuildpy.finalize_options which is # too late for some cases return not self.pure and Distribution.has_ext_modules(self)
def install_connector(root_dir, install_dir, protobuf_include_dir, protobuf_lib_dir, protoc, connc_location=None, extra_compile_args=None, extra_link_args=None, debug=False): """Install Connector/Python in working directory """ logfile = 'myconnpy_install.log' LOGGER.info("Installing Connector/Python in {0}".format(install_dir)) try: # clean up previous run if os.path.exists(logfile): os.unlink(logfile) shutil.rmtree(install_dir) except OSError: pass cmd = [ sys.executable, 'setup.py', 'clean', '--all', # necessary for removing the build/ ] dist = Distribution() cmd_build = dist.get_command_obj('build') cmd_build.ensure_finalized() cmd.extend([ 'install', '--root', install_dir, '--install-lib', '.', '--static', '--is-wheel' ]) if os.name == 'nt': cmd.extend([ '--install-data', cmd_build.build_platlib ]) if any((protobuf_include_dir, protobuf_lib_dir, protoc)): cmd.extend([ '--with-protobuf-include-dir', protobuf_include_dir, '--with-protobuf-lib-dir', protobuf_lib_dir, '--with-protoc', protoc, ]) if connc_location: cmd.extend(['--with-mysql-capi', connc_location]) if extra_compile_args: cmd.extend(['--extra-compile-args', extra_compile_args]) if extra_link_args: cmd.extend(['--extra-link-args', extra_link_args]) LOGGER.debug("Installing command: {0}".format(cmd)) prc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, cwd=root_dir) stdout = prc.communicate()[0] if prc.returncode is not 0: with open(logfile, 'wb') as logfp: logfp.write(stdout) LOGGER.error("Failed installing Connector/Python, see {log}".format( log=logfile)) if debug: with open(logfile) as logfr: print(logfr.read()) sys.exit(1)
def test_obsoletes_to_list(self): attrs = {"name": "package", "obsoletes": iter(["other"])} dist = Distribution(attrs) self.assertIsInstance(dist.metadata.obsoletes, list)
def __init__(self, *args, **kwargs): self.package_data = None Distribution.__init__(self, *args, **kwargs)
# serve to show the default. import sys, os # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.insert(0, os.path.abspath('.')) # This should locate the parent directory for atomac sys.path.insert(0, os.path.abspath('..')) # Get info about the _a11y extension first import distutils.command.build from distutils.dist import Distribution b = distutils.command.build.build(Distribution()) b.initialize_options() b.finalize_options() # Add to sys.path the path to the library build directory # This will work only if the library has been built from commandline via # python setup.py build # TODO: Integrate building the _a11y module before building the docs sys.path.insert(0, os.path.join(os.path.abspath('..'), b.build_platlib)) # -- General configuration ----------------------------------------------------- # If your documentation needs a minimal Sphinx version, state it here. #needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be extensions
def test_classifier(self): attrs = {'name': 'Boa', 'version': '3.0', 'classifiers': ['Programming Language :: Python :: 3']} dist = Distribution(attrs) meta = self.format_metadata(dist) self.assertIn('Metadata-Version: 1.1', meta)
def distutils_scheme( dist_name, user=False, home=None, root=None, isolated=False, prefix=None ): # type:(str, bool, str, str, bool, str) -> Dict[str, str] """ Return a distutils install scheme """ from distutils.dist import Distribution dist_args = {'name': dist_name} # type: Dict[str, Union[str, List[str]]] if isolated: dist_args["script_args"] = ["--no-user-cfg"] d = Distribution(dist_args) d.parse_config_files() obj = None # type: Optional[DistutilsCommand] obj = d.get_command_obj('install', create=True) assert obj is not None i = cast(distutils_install_command, obj) # NOTE: setting user or home has the side-effect of creating the home dir # or user base for installations during finalize_options() # ideally, we'd prefer a scheme class that has no side-effects. assert not (user and prefix), f"user={user} prefix={prefix}" assert not (home and prefix), f"home={home} prefix={prefix}" i.user = user or i.user if user or home: i.prefix = "" i.prefix = prefix or i.prefix i.home = home or i.home i.root = root or i.root i.finalize_options() scheme = {} for key in SCHEME_KEYS: scheme[key] = getattr(i, 'install_' + key) # install_lib specified in setup.cfg should install *everything* # into there (i.e. it takes precedence over both purelib and # platlib). Note, i.install_lib is *always* set after # finalize_options(); we only want to override here if the user # has explicitly requested it hence going back to the config if 'install_lib' in d.get_option_dict('install'): scheme.update(dict(purelib=i.install_lib, platlib=i.install_lib)) if running_under_virtualenv(): scheme['headers'] = os.path.join( i.prefix, 'main', 'site', f'python{get_major_minor_version()}', dist_name, ) if root is not None: path_no_drive = os.path.splitdrive( os.path.abspath(scheme["headers"]))[1] scheme["headers"] = os.path.join( root, path_no_drive[1:], ) return scheme
def build_lib_dirname(): from distutils.dist import Distribution from distutils.command.build import build build_cmd = build(Distribution({"ext_modules": True})) build_cmd.finalize_options() return build_cmd.build_lib
import sys from distutils.dist import Distribution from distutils.extension import Extension from distutils.command.build_ext import build_ext ext = Extension('jsbsim', []) name = build_ext(Distribution()).get_ext_filename(ext.name) sys.stdout.write(name)