diff options
author | Constantine Evans <cevans@evanslabs.org> | 2017-05-08 19:23:56 -0700 |
---|---|---|
committer | Constantine Evans <cevans@evanslabs.org> | 2017-05-08 19:23:56 -0700 |
commit | 8ec4cd173689eeb972da52701b1e1293d4121944 (patch) | |
tree | aa4b78f3401cf4e832c3e0d21067731f93f1728c | |
parent | e9589e8139242774c0e52b3fcc07d70c2d836238 (diff) | |
download | ruamel.yaml-8ec4cd173689eeb972da52701b1e1293d4121944.tar.gz |
Add setup.py from release.
-rw-r--r-- | .hgignore | 1 | ||||
-rw-r--r-- | setup.py | 858 |
2 files changed, 858 insertions, 1 deletions
@@ -14,7 +14,6 @@ syntax: glob dist build *.egg-info -setup.py # tox related .tox .cache diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..98e86df --- /dev/null +++ b/setup.py @@ -0,0 +1,858 @@ +# # header +# coding: utf-8 + +from __future__ import print_function, absolute_import, division, unicode_literals + +# # __init__.py parser + +import sys +import os +import datetime +sys.path = [path for path in sys.path if path not in [os.getcwd(), '']] +import platform # NOQA +from _ast import * # NOQA +from ast import parse # NOQA + +from setuptools import setup, Extension, Distribution # NOQA +from setuptools.command import install_lib # NOQA + +if __name__ != '__main__': + raise NotImplementedError('should never include setup.py') + +# # definitions + +full_package_name = None + +if __name__ != '__main__': + raise NotImplementedError('should never include setup.py') + +if sys.version_info < (3, ): + string_type = basestring +else: + string_type = str + + +if sys.version_info < (3, 4): + class Bytes(): + pass + + class NameConstant: + pass + +if sys.version_info < (3, ): + open_kw = dict() +else: + open_kw = dict(encoding='utf-8') + + +if sys.version_info < (2, 7) or platform.python_implementation() == 'Jython': + class Set(): + pass + + +def literal_eval(node_or_string): + """ + Safely evaluate an expression node or a string containing a Python + expression. The string or node provided may only consist of the following + Python literal structures: strings, bytes, numbers, tuples, lists, dicts, + sets, booleans, and None. + """ + _safe_names = {'None': None, 'True': True, 'False': False} + if isinstance(node_or_string, string_type): + node_or_string = parse(node_or_string, mode='eval') + if isinstance(node_or_string, Expression): + node_or_string = node_or_string.body + else: + raise TypeError("only string or AST nodes supported") + + def _convert(node): + if isinstance(node, (Str, Bytes)): + return node.s + elif isinstance(node, Num): + return node.n + elif isinstance(node, Tuple): + return tuple(map(_convert, node.elts)) + elif isinstance(node, List): + return list(map(_convert, node.elts)) + elif isinstance(node, Set): + return set(map(_convert, node.elts)) + elif isinstance(node, Dict): + return dict((_convert(k), _convert(v)) for k, v + in zip(node.keys, node.values)) + elif isinstance(node, NameConstant): + return node.value + elif sys.version_info < (3, 4) and isinstance(node, Name): + if node.id in _safe_names: + return _safe_names[node.id] + elif isinstance(node, UnaryOp) and \ + isinstance(node.op, (UAdd, USub)) and \ + isinstance(node.operand, (Num, UnaryOp, BinOp)): # NOQA + operand = _convert(node.operand) + if isinstance(node.op, UAdd): + return + operand + else: + return - operand + elif isinstance(node, BinOp) and \ + isinstance(node.op, (Add, Sub)) and \ + isinstance(node.right, (Num, UnaryOp, BinOp)) and \ + isinstance(node.left, (Num, UnaryOp, BinOp)): # NOQA + left = _convert(node.left) + right = _convert(node.right) + if isinstance(node.op, Add): + return left + right + else: + return left - right + elif isinstance(node, Call): + func_id = getattr(node.func, 'id', None) + if func_id == 'dict': + return dict((k.arg, _convert(k.value)) for k in node.keywords) + elif func_id == 'set': + return set(_convert(node.args[0])) + elif func_id == 'date': + return datetime.date(*[_convert(k) for k in node.args]) + elif func_id == 'datetime': + return datetime.datetime(*[_convert(k) for k in node.args]) + err = SyntaxError('malformed node or string: ' + repr(node)) + err.filename = '<string>' + err.lineno = node.lineno + err.offset = node.col_offset + err.text = repr(node) + err.node = node + raise err + return _convert(node_or_string) + + +# parses python ( "= dict( )" ) or ( "= {" ) +def _package_data(fn): + data = {} + with open(fn, **open_kw) as fp: + parsing = False + lines = [] + for line in fp.readlines(): + if sys.version_info < (3,): + line = line.decode('utf-8') + if line.startswith(u'_package_data'): + if 'dict(' in line: + parsing = 'python' + lines.append(u'dict(\n') + elif line.endswith(u'= {\n'): + parsing = 'python' + lines.append(u'{\n') + else: + raise NotImplementedError + continue + if not parsing: + continue + if parsing == 'python': + if line.startswith(u')') or line.startswith(u'}'): + lines.append(line) + try: + data = literal_eval(u''.join(lines)) + except SyntaxError as e: + context = 2 + from_line = e.lineno - (context + 1) + to_line = e.lineno + (context - 1) + w = len(str(to_line)) + for index, line in enumerate(lines): + if from_line <= index <= to_line: + print(u"{0:{1}}: {2}".format(index, w, line).encode('utf-8'), + end=u'') + if index == e.lineno - 1: + print(u"{0:{1}} {2}^--- {3}".format( + u' ', w, u' ' * e.offset, e.node)) + raise + break + lines.append(line) + else: + raise NotImplementedError + return data + +# make sure you can run "python ../some/dir/setup.py install" +pkg_data = _package_data(__file__.replace('setup.py', '__init__.py')) + +exclude_files = [ + 'setup.py', +] + + +# # helper +def _check_convert_version(tup): + """Create a PEP 386 pseudo-format conformant string from tuple tup.""" + ret_val = str(tup[0]) # first is always digit + next_sep = "." # separator for next extension, can be "" or "." + nr_digits = 0 # nr of adjacent digits in rest, to verify + post_dev = False # are we processig post/dev + for x in tup[1:]: + if isinstance(x, int): + nr_digits += 1 + if nr_digits > 2: + raise ValueError("too many consecutive digits after " + ret_val) + ret_val += next_sep + str(x) + next_sep = '.' + continue + first_letter = x[0].lower() + next_sep = '' + if first_letter in 'abcr': + if post_dev: + raise ValueError("release level specified after " + "post/dev: " + x) + nr_digits = 0 + ret_val += 'rc' if first_letter == 'r' else first_letter + elif first_letter in 'pd': + nr_digits = 1 # only one can follow + post_dev = True + ret_val += '.post' if first_letter == 'p' else '.dev' + else: + raise ValueError('First letter of "' + x + '" not recognised') + # .dev and .post need a number otherwise setuptools normalizes and complains + if nr_digits == 1 and post_dev: + ret_val += '0' + return ret_val + + +version_info = pkg_data['version_info'] +version_str = _check_convert_version(version_info) + + +class MyInstallLib(install_lib.install_lib): + def install(self): + fpp = pkg_data['full_package_name'].split('.') # full package path + full_exclude_files = [os.path.join(*(fpp + [x])) + for x in exclude_files] + alt_files = [] + outfiles = install_lib.install_lib.install(self) + for x in outfiles: + for full_exclude_file in full_exclude_files: + if full_exclude_file in x: + os.remove(x) + break + else: + alt_files.append(x) + return alt_files + + +class InMemoryZipFile(object): + def __init__(self, file_name=None): + try: + from cStringIO import StringIO + except ImportError: + from io import BytesIO as StringIO + import zipfile + self.zip_file = zipfile + # Create the in-memory file-like object + self._file_name = file_name + self.in_memory_data = StringIO() + # Create the in-memory zipfile + self.in_memory_zip = self.zip_file.ZipFile( + self.in_memory_data, "w", self.zip_file.ZIP_DEFLATED, False) + self.in_memory_zip.debug = 3 + + def append(self, filename_in_zip, file_contents): + '''Appends a file with name filename_in_zip and contents of + file_contents to the in-memory zip.''' + self.in_memory_zip.writestr(filename_in_zip, file_contents) + return self # so you can daisy-chain + + def write_to_file(self, filename): + '''Writes the in-memory zip to a file.''' + # Mark the files as having been created on Windows so that + # Unix permissions are not inferred as 0000 + for zfile in self.in_memory_zip.filelist: + zfile.create_system = 0 + self.in_memory_zip.close() + with open(filename, 'wb') as f: + f.write(self.in_memory_data.getvalue()) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + if self._file_name is None: + return + self.write_to_file(self._file_name) + + def delete_from_zip_file(self, pattern=None, file_names=None): + """ + zip_file can be a string or a zipfile.ZipFile object, the latter will be closed + any name in file_names is deleted, all file_names provided have to be in the ZIP + archive or else an IOError is raised + """ + if pattern and isinstance(pattern, string_type): + import re + pattern = re.compile(pattern) + if file_names: + if not isinstance(file_names, list): + file_names = [file_names] + else: + file_names = [] + with self.zip_file.ZipFile(self._file_name) as zf: + for l in zf.infolist(): + if l.filename in file_names: + file_names.remove(l.filename) + continue + if pattern and pattern.match(l.filename): + continue + self.append(l.filename, zf.read(l)) + if file_names: + raise IOError('[Errno 2] No such file{}: {}'.format( + '' if len(file_names) == 1 else 's', + ', '.join([repr(f) for f in file_names]))) + + +class NameSpacePackager(object): + def __init__(self, pkg_data): + assert isinstance(pkg_data, dict) + self._pkg_data = pkg_data + self.full_package_name = self.pn(self._pkg_data['full_package_name']) + self._split = None + self.depth = self.full_package_name.count('.') + self.nested = self._pkg_data.get('nested', False) + self.command = None + self.python_version() + self._pkg = [None, None] # required and pre-installable packages + if sys.argv[0] == 'setup.py' and sys.argv[1] == 'install' and \ + '--single-version-externally-managed' not in sys.argv: + if os.environ.get('READTHEDOCS', None) == 'True': + os.system('pip install .') + sys.exit(0) + if not os.environ.get('RUAMEL_NO_PIP_INSTALL_CHECK', False): + print('error: you have to install with "pip install ."') + sys.exit(1) + # If you only support an extension module on Linux, Windows thinks it + # is pure. That way you would get pure python .whl files that take + # precedence for downloading on Linux over source with compilable C + if self._pkg_data.get('universal'): + Distribution.is_pure = lambda *args: True + else: + Distribution.is_pure = lambda *args: False + for x in sys.argv: + if x[0] == '-' or x == 'setup.py': + continue + self.command = x + break + + def pn(self, s): + if sys.version_info < (3, ) and isinstance(s, unicode): + return s.encode('utf-8') + return s + + @property + def split(self): + """split the full package name in list of compontents traditionally + done by setuptools.find_packages. This routine skips any directories + with __init__.py that start with "_" or ".", or contain a + setup.py/tox.ini (indicating a subpackage) + """ + if self._split is None: + fpn = self.full_package_name.split('.') + self._split = [] + while fpn: + self._split.insert(0, '.'.join(fpn)) + fpn = fpn[:-1] + for d in os.listdir('.'): + if not os.path.isdir(d) or d == self._split[0] or d[0] in '._': + continue + # prevent sub-packages in namespace from being included + x = os.path.join(d, 'setup.py') + if os.path.exists(x): + if not os.path.exists(os.path.join(d, 'tox.ini')): + print('\n>>>>> found "{0}" without tox.ini <<<<<\n' + ''.format(x)) + continue + x = os.path.join(d, '__init__.py') + if os.path.exists(x): + self._split.append(self.full_package_name + '.' + d) + if sys.version_info < (3, ): + self._split = [(y.encode('utf-8') if isinstance(y, unicode) else y) + for y in self._split] + return self._split + + @property + def namespace_packages(self): + return self.split[:self.depth] + + def namespace_directories(self, depth=None): + """return list of directories where the namespace should be created / + can be found + """ + res = [] + for index, d in enumerate(self.split[:depth]): + # toplevel gets a dot + if index > 0: + d = os.path.join(*d.split('.')) + res.append('.' + d) + return res + + @property + def package_dir(self): + d = { + # don't specify empty dir, clashes with package_data spec + self.full_package_name: '.', + } + if len(self.split) > 1: # only if package namespace + d[self.split[0]] = self.namespace_directories(1)[0] + return d + + def create_dirs(self): + """create the directories necessary for namespace packaging""" + directories = self.namespace_directories(self.depth) + if not directories: + return + if not os.path.exists(directories[0]): + for d in directories: + os.mkdir(d) + with open(os.path.join(d, '__init__.py'), 'w') as fp: + fp.write('import pkg_resources\n' + 'pkg_resources.declare_namespace(__name__)\n') + + def python_version(self): + supported = self._pkg_data.get('supported') + if supported is None: + return + if len(supported) == 1: + minimum = supported[0] + else: + for x in supported: + if x[0] == sys.version_info[0]: + minimum = x + break + else: + return + if sys.version_info < minimum: + print('minimum python version(s): ' + str(supported)) + sys.exit(1) + + def check(self): + try: + from pip.exceptions import InstallationError + except ImportError: + return + # arg is either develop (pip install -e) or install + if self.command not in ['install', 'develop']: + return + + # if hgi and hgi.base are both in namespace_packages matching + # against the top (hgi.) it suffices to find minus-e and non-minus-e + # installed packages. As we don't know the order in namespace_packages + # do some magic + prefix = self.split[0] + prefixes = set([prefix, prefix.replace('_', '-')]) + for p in sys.path: + if not p: + continue # directory with setup.py + if os.path.exists(os.path.join(p, 'setup.py')): + continue # some linked in stuff might not be hgi based + if not os.path.isdir(p): + continue + if p.startswith('/tmp/'): + continue + for fn in os.listdir(p): + for pre in prefixes: + if fn.startswith(pre): + break + else: + continue + full_name = os.path.join(p, fn) + # not in prefixes the toplevel is never changed from _ to - + if fn == prefix and os.path.isdir(full_name): + # directory -> other, non-minus-e, install + if self.command == 'develop': + raise InstallationError( + 'Cannot mix develop (pip install -e),\nwith ' + 'non-develop installs for package name {0}'.format( + fn)) + elif fn == prefix: + raise InstallationError( + 'non directory package {0} in {1}'.format( + fn, p)) + for pre in [x + '.' for x in prefixes]: + if fn.startswith(pre): + break + else: + continue # hgiabc instead of hgi. + if fn.endswith('-link') and self.command == 'install': + raise InstallationError( + 'Cannot mix non-develop with develop\n(pip install -e)' + ' installs for package name {0}'.format(fn)) + + def entry_points(self, script_name=None, package_name=None): + """normally called without explicit script_name and package name + the default console_scripts entry depends on the existence of __main__.py: + if that file exists then the function main() in there is used, otherwise + the in __init__.py. + + the _package_data entry_points key/value pair can be explicitly specified + including a "=" character. If the entry is True or 1 the + scriptname is the last part of the full package path (split on '.') + if the ep entry is a simple string without "=", that is assumed to be + the name of the script. + """ + def pckg_entry_point(name): + return '{0}{1}:main'.format( + name, + '.__main__' if os.path.exists('__main__.py') else '', + ) + + ep = self._pkg_data.get('entry_points', True) + if ep is None: + return None + if ep not in [True, 1]: + if '=' in ep: + # full specification of the entry point like + # entry_points=['yaml = ruamel.yaml.cmd:main'], + return {'console_scripts': [ep]} + # assume that it is just the script name + script_name = ep + if package_name is None: + package_name = self.full_package_name + if not script_name: + script_name = package_name.split('.')[-1] + return {'console_scripts': [ + '{0} = {1}'.format(script_name, pckg_entry_point(package_name)), + ]} + + @property + def url(self): + if self.full_package_name.startswith('ruamel.'): + sp = self.full_package_name.split('.', 1) + else: + sp = ['ruamel', self.full_package_name] + return 'https://bitbucket.org/{0}/{1}'.format(*sp) + + @property + def author(self): + return self._pkg_data['author'] + + @property + def author_email(self): + return self._pkg_data['author_email'] + + @property + def license(self): + """return the license field from _package_data, None means MIT""" + lic = self._pkg_data.get('license') + if lic is None: + # lic_fn = os.path.join(os.path.dirname(__file__), 'LICENSE') + # assert os.path.exists(lic_fn) + return "MIT license" + return lic + + def has_mit_lic(self): + return 'MIT' in self.license + + @property + def description(self): + return self._pkg_data['description'] + + @property + def status(self): + # αβ + status = self._pkg_data.get('status', u'β').lower() + if status in [u'α', u'alpha']: + return (3, 'Alpha') + elif status in [u'β', u'beta']: + return (4, 'Beta') + elif u'stable' in status.lower(): + return (5, 'Production/Stable') + raise NotImplementedError + + @property + def classifiers(self): + return [ + 'Development Status :: {0} - {1}'.format(*self.status), + 'Intended Audience :: Developers', + 'License :: ' + ('OSI Approved :: MIT' if self.has_mit_lic() + else 'Other/Proprietary') + ' License', + 'Operating System :: OS Independent', + 'Programming Language :: Python', + ] + [self.pn(x) for x in self._pkg_data.get('classifiers', [])] + + @property + def keywords(self): + return self.pn(self._pkg_data.get('keywords')) + + @property + def install_requires(self): + """list of packages required for installation""" + return self._analyse_packages[0] + + @property + def install_pre(self): + """list of packages required for installation""" + return self._analyse_packages[1] + + @property + def _analyse_packages(self): + """gather from configuration, names starting with * need + to be installed explicitly as they are not on PyPI + install_requires should be dict, with keys 'any', 'py27' etc + or a list (which is as if only 'any' was defined + + ToDo: update with: pep508 conditional dependencies + https://www.python.org/dev/peps/pep-0508/ + https://wheel.readthedocs.io/en/latest/index.html#defining-conditional-dependencies + https://hynek.me/articles/conditional-python-dependencies/ + """ + if self._pkg[0] is None: + self._pkg[0] = [] + self._pkg[1] = [] + + ir = self._pkg_data.get('install_requires') + if ir is None: + return self._pkg # these will be both empty at this point + if isinstance(ir, list): + self._pkg[0] = ir + return self._pkg + # 'any' for all builds, 'py27' etc for specifics versions + packages = ir.get('any', []) + if isinstance(packages, string_type): + packages = packages.split() # assume white space separated string + if self.nested: + # parent dir is also a package, make sure it is installed (need its .pth file) + parent_pkg = self.full_package_name.rsplit('.', 1)[0] + if parent_pkg not in packages: + packages.append(parent_pkg) + implementation = platform.python_implementation() + if implementation == 'CPython': + pyver = 'py{0}{1}'.format(*sys.version_info) + elif implementation == 'PyPy': + pyver = 'pypy' if sys.version_info < (3, ) else 'pypy3' + elif implementation == 'Jython': + pyver = 'jython' + packages.extend(ir.get(pyver, [])) + for p in packages: + # package name starting with * means use local source tree, non-published + # to PyPi or maybe not latest version on PyPI -> pre-install + if p[0] == '*': + p = p[1:] + self._pkg[1].append(p) + self._pkg[0].append(p) + return self._pkg + + @property + def data_files(self): + df = self._pkg_data.get('data_files', []) + if self.has_mit_lic(): + df.append('LICENSE') + if not df: + return None + return [('.', df), ] + + @property + def package_data(self): + df = self._pkg_data.get('data_files', []) + if self.has_mit_lic(): + # include the file + df.append('LICENSE') + # but don't install it + exclude_files.append('LICENSE') + if not df: + return {} + return {self.full_package_name: df} + + @property + def ext_modules(self): + """check if all modules specified in the value for 'ext_modules' can be build + that value (if not None) is a list of dicts with 'name', 'src', 'lib' + Optional 'test' can be used to make sure trying to compile will work on the host + + creates and return the external modules as Extensions, unless that + is not necessary at all for the action (like --version) + + test existence of compiler by using export CC=nonexistent; export CXX=nonexistent + """ + + if hasattr(self, '_ext_modules'): + return self._ext_modules + if '--version' in sys.argv: + return None + if platform.python_implementation() == 'Jython': + return None + if sys.platform == "win32" and not self._pkg_data.get('win32bin'): + return None + try: + plat = sys.argv.index('--plat-name') + if 'win' in sys.argv[plat + 1]: + return None + except ValueError: + pass + self._ext_modules = [] + no_test_compile = False + if '--restructuredtext' in sys.argv: + no_test_compile = True + elif 'sdist' in sys.argv: + no_test_compile = True + if no_test_compile: + for target in self._pkg_data.get('ext_modules', []): + ext = Extension( + self.pn(target['name']), + sources=[self.pn(x) for x in target['src']], + libraries=[self.pn(x) for x in target.get('lib')], + ) + self._ext_modules.append(ext) + return self._ext_modules + + print('sys.argv', sys.argv) + import tempfile + import shutil + from textwrap import dedent + + import distutils.sysconfig + import distutils.ccompiler + from distutils.errors import CompileError, LinkError + + for target in self._pkg_data.get('ext_modules', []): # list of dicts + ext = Extension( + self.pn(target['name']), + sources=[self.pn(x) for x in target['src']], + libraries=[self.pn(x) for x in target.get('lib')], + ) + if 'test' not in target: # no test just hope it works + self._ext_modules.append(ext) + continue + # write a temporary .c file to compile + c_code = dedent(target['test']) + try: + tmp_dir = tempfile.mkdtemp(prefix='tmp_ruamel_') + bin_file_name = 'test' + self.pn(target['name']) + print('test compiling', bin_file_name) + file_name = os.path.join(tmp_dir, bin_file_name + '.c') + with open(file_name, 'w') as fp: # write source + fp.write(c_code) + # and try to compile it + compiler = distutils.ccompiler.new_compiler() + assert isinstance(compiler, distutils.ccompiler.CCompiler) + # do any platform specific initialisations + distutils.sysconfig.customize_compiler(compiler) + # make sure you can reach header files because compile does change dir + compiler.add_include_dir(os.getcwd()) + if sys.version_info < (3, ): + tmp_dir = tmp_dir.encode('utf-8') + # used to be a different directory, not necessary + compile_out_dir = tmp_dir + try: + compiler.link_executable( + compiler.compile( + [file_name], + output_dir=compile_out_dir, + ), + bin_file_name, + output_dir=tmp_dir, + libraries=ext.libraries, + ) + except CompileError: + print('compile error:', file_name) + continue + except LinkError: + print('libyaml link error', file_name) + continue + self._ext_modules.append(ext) + except Exception as e: # NOQA + print('Exception:', e) + pass + finally: + shutil.rmtree(tmp_dir) + return self._ext_modules + + def wheel(self, kw, setup): + """temporary add setup.cfg if creating a wheel to include LICENSE file + https://bitbucket.org/pypa/wheel/issues/47 + """ + if 'bdist_wheel' not in sys.argv: + return + file_name = 'setup.cfg' + if os.path.exists(file_name): # add it if not in there? + return + with open(file_name, 'w') as fp: + if os.path.exists('LICENSE'): + fp.write('[metadata]\nlicense-file = LICENSE\n') + else: + print("\n\n>>>>>> LICENSE file not found <<<<<\n\n") + if self._pkg_data.get('universal'): + fp.write('[bdist_wheel]\nuniversal = 1\n') + try: + setup(**kw) + except: + raise + finally: + os.remove(file_name) + return True + + +# # call setup +def main(): + dump_kw = '--dump-kw' + if dump_kw in sys.argv: + import wheel + import distutils + print('python: ', sys.version) + print('distutils:', distutils.__version__) + print('wheel: ', wheel.__version__) + nsp = NameSpacePackager(pkg_data) + nsp.check() + nsp.create_dirs() + kw = dict( + name=nsp.full_package_name, + namespace_packages=nsp.namespace_packages, + version=version_str, + packages=nsp.split, + url=nsp.url, + author=nsp.author, + author_email=nsp.author_email, + cmdclass={'install_lib': MyInstallLib}, + package_dir=nsp.package_dir, + entry_points=nsp.entry_points(), + description=nsp.description, + install_requires=nsp.install_requires, + license=nsp.license, + classifiers=nsp.classifiers, + keywords=nsp.keywords, + package_data=nsp.package_data, + ext_modules=nsp.ext_modules, + ) + if '--version' not in sys.argv and ('--verbose' in sys.argv or dump_kw in sys.argv): + for k in sorted(kw): + v = kw[k] + print(' "{0}": "{1}",'.format(k, v)) + if dump_kw in sys.argv: + sys.argv.remove(dump_kw) + try: + with open('README.rst') as fp: + kw['long_description'] = fp.read() + except: + pass + if nsp.wheel(kw, setup): + return + for x in ['-c', 'egg_info', '--egg-base', 'pip-egg-info']: + if x not in sys.argv: + break + else: + # we're doing a tox setup install any starred package by searching up the source tree + # until you match your/package/name for your.package.name + for p in nsp.install_pre: + import subprocess + # search other source + setup_path = os.path.join(*p.split('.') + ['setup.py']) + try_dir = os.path.dirname(sys.executable) + while len(try_dir) > 1: + full_path_setup_py = os.path.join(try_dir, setup_path) + if os.path.exists(full_path_setup_py): + pip = sys.executable.replace('python', 'pip') + cmd = [pip, 'install', os.path.dirname(full_path_setup_py)] + # with open('/var/tmp/notice', 'a') as fp: + # print('installing', cmd, file=fp) + subprocess.check_output(cmd) + break + try_dir = os.path.dirname(try_dir) + setup(**kw) + if nsp.nested and sys.argv[:2] == ['-c', 'bdist_wheel']: + d = sys.argv[sys.argv.index('-d')+1] + for x in os.listdir(d): + if x.endswith('.whl'): + # remove .pth file from the wheel + full_name = os.path.join(d, x) + with InMemoryZipFile(full_name) as imz: + imz.delete_from_zip_file(nsp.full_package_name + '.*.pth') + break + +main() |