# # header
# coding: utf-8
# dd: 20200903
from __future__ import print_function, absolute_import, division, unicode_literals
# # __init__.py parser
import sys
import os
import datetime
import traceback
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
from setuptools.command.sdist import sdist as _sdist # NOQA
try:
from setuptools.namespaces import Installer as NameSpaceInstaller # NOQA
except ImportError:
msg = ('You should use the latest setuptools. The namespaces.py file that this setup.py'
' uses was added in setuptools 28.7.0 (Oct 2016)')
print(msg)
sys.exit()
if __name__ != '__main__':
raise NotImplementedError('should never include setup.py')
# # definitions
full_package_name = None
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, 8):
from ast import Str, Num, Bytes, NameConstant # NOQA
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
if os.environ.get('DVDEBUG', "") == "":
def debug(*args, **kw):
pass
else:
def debug(*args, **kw):
with open(os.environ['DVDEBUG'], 'a') as fp:
kw1 = kw.copy()
kw1['file'] = fp
print('{:%Y-%d-%mT%H:%M:%S}'.format(datetime.datetime.now()), file=fp, end=' ')
print(*args, **kw1)
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.
Even when passing in Unicode, the resulting Str types parsed are 'str' in Python 2.
I don't now how to set 'unicode_literals' on parse -> Str is explicitly converted.
"""
_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):
if sys.version_info < (3,) and not isinstance(node.s, unicode):
return node.s.decode('utf-8')
return node.s
elif isinstance(node, 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('_package_data'):
if 'dict(' in line:
parsing = 'python'
lines.append('dict(\n')
elif line.endswith('= {\n'):
parsing = 'python'
lines.append('{\n')
else:
raise NotImplementedError
continue
if not parsing:
continue
if parsing == 'python':
if line.startswith(')') or line.startswith('}'):
lines.append(line)
try:
data = literal_eval("".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(
'{0:{1}}: {2}'.format(index, w, line).encode('utf-8'),
end="",
)
if index == e.lineno - 1:
print(
'{0:{1}} {2}^--- {3}'.format(
' ', w, ' ' * 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 MySdist(_sdist):
def initialize_options(self):
_sdist.initialize_options(self)
# see pep 527, new uploads should be tar.gz or .zip
# fmt = getattr(self, 'tarfmt', None)
# because of unicode_literals
# self.formats = fmt if fmt else [b'bztar'] if sys.version_info < (3, ) else ['bztar']
dist_base = os.environ.get('PYDISTBASE')
fpn = getattr(getattr(self, 'nsp', self), 'full_package_name', None)
if fpn and dist_base:
print('setting distdir {}/{}'.format(dist_base, fpn))
self.dist_dir = os.path.join(dist_base, fpn)
# try except so this doesn't bomb when you don't have wheel installed, implies
# generation of wheels in ./dist
try:
from wheel.bdist_wheel import bdist_wheel as _bdist_wheel # NOQA
class MyBdistWheel(_bdist_wheel):
def initialize_options(self):
_bdist_wheel.initialize_options(self)
dist_base = os.environ.get('PYDISTBASE')
fpn = getattr(getattr(self, 'nsp', self), 'full_package_name', None)
if fpn and dist_base:
print('setting distdir {}/{}'.format(dist_base, fpn))
self.dist_dir = os.path.join(dist_base, fpn)
_bdist_wheel_available = True
except ImportError:
_bdist_wheel_available = False
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)
if self.nested:
NameSpaceInstaller.install_namespaces = lambda x: None
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':
debug('calling setup.py', sys.argv)
if '-h' in sys.argv:
pass
elif '--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 code
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, for which the name starts with "_" or ".", or contain a
setup.py/tox.ini (indicating a subpackage)
"""
skip = []
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 sorted(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, '__init__.py')
if os.path.exists(x):
pd = _package_data(x)
if pd.get('nested', False):
skip.append(d)
continue
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
]
if skip:
# this interferes with output checking
# print('skipping sub-packages:', ', '.join(skip))
pass
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 'extra_packages' in self._pkg_data:
return d
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):
# https://github.com/pypa/setuptools/issues/2355#issuecomment-685159580
InstallationError = Exception
# 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 isinstance(ep, dict):
return ep
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):
url = self._pkg_data.get('url')
if url:
return url
sp = self.full_package_name
for ch in '_.':
sp = sp.replace(ch, '-')
return 'https://sourceforge.net/p/{0}/code/ci/default/tree'.format(sp)
@property
def author(self):
return self._pkg_data['author'] # no get needs to be there
@property
def author_email(self):
return self._pkg_data['author_email'] # no get needs to be there
@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'] # no get needs to be there
@property
def status(self):
# αβ
status = self._pkg_data.get('status', 'β').lower()
if status in ['α', 'alpha']:
return (3, 'Alpha')
elif status in ['β', 'beta']:
return (4, 'Beta')
elif 'stable' in status.lower():
return (5, 'Production/Stable')
raise NotImplementedError
@property
def classifiers(self):
"""this needs more intelligence, probably splitting the classifiers from _pkg_data
and only adding defaults when no explicit entries were provided.
Add explicit Python versions in sync with tox.env generation based on python_requires?
"""
attr = '_' + sys._getframe().f_code.co_name
if not hasattr(self, attr):
setattr(self, attr, self._setup_classifiers())
return getattr(self, attr)
def _setup_classifiers(self):
return sorted(
set(
[
'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
"""
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 extras_require(self):
"""dict of conditions -> extra packages informaton required for installation
as of setuptools 33 doing `package ; python_version<=2.7' in install_requires
still doesn't work
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/
"""
ep = self._pkg_data.get('extras_require')
return ep
# @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 self._pkg_data.get('binary_only', False):
exclude_files.append('__init__.py')
debug('testing<<<<<')
if 'Typing :: Typed' in self.classifiers:
debug('appending')
df.append('py.typed')
pd = self._pkg_data.get('package_data', {})
if df:
pd[self.full_package_name] = df
if sys.version_info < (3,):
# python2 doesn't seem to like unicode package names as keys
# maybe only when the packages themselves are non-unicode
for k in pd:
if isinstance(k, unicode):
pd[str(k)] = pd.pop(k)
# for k in pd:
# pd[k] = [e.encode('utf-8') for e in pd[k]] # de-unicode
return pd
@property
def packages(self):
s = self.split
# fixed this in package_data, the keys there must be non-unicode for py27
# if sys.version_info < (3, 0):
# s = [x.encode('utf-8') for x in self.split]
return s + self._pkg_data.get('extra_packages', [])
@property
def python_requires(self):
return self._pkg_data.get('python_requires', None)
@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
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')],
)
# debug('test1 in target', 'test' in target, target)
if 'test' not in target: # no test, just hope it works
self._ext_modules.append(ext)
continue
if sys.version_info[:2] == (3, 4) and platform.system() == 'Windows':
# this is giving problems on appveyor, so skip
if 'FORCE_C_BUILD_TEST' not in os.environ:
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'])
file_name = os.path.join(tmp_dir, bin_file_name + '.c')
print('test compiling', file_name, '->', bin_file_name, end=' ')
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:
debug('compile error:', file_name)
print('compile error:', file_name)
raise
except LinkError:
debug('link error', file_name)
print('link error', file_name)
raise
print('OK')
self._ext_modules.append(ext)
except Exception as e: # NOQA
debug('Exception:', e)
print('Exception:', e)
sys.exit(1)
if sys.version_info[:2] == (3, 4) and platform.system() == 'Windows':
traceback.print_exc()
finally:
shutil.rmtree(tmp_dir)
return self._ext_modules
@property
def test_suite(self):
return self._pkg_data.get('test_suite')
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 False
file_name = 'setup.cfg'
if os.path.exists(file_name): # add it if not in there?
return False
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 Exception:
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
import setuptools
print('python: ', sys.version)
print('setuptools:', setuptools.__version__)
print('distutils: ', distutils.__version__)
print('wheel: ', wheel.__version__)
nsp = NameSpacePackager(pkg_data)
nsp.check()
nsp.create_dirs()
MySdist.nsp = nsp
if pkg_data.get('tarfmt'):
MySdist.tarfmt = pkg_data.get('tarfmt')
cmdclass = dict(install_lib=MyInstallLib, sdist=MySdist)
if _bdist_wheel_available:
MyBdistWheel.nsp = nsp
cmdclass['bdist_wheel'] = MyBdistWheel
kw = dict(
name=nsp.full_package_name,
namespace_packages=nsp.namespace_packages,
version=version_str,
packages=nsp.packages,
python_requires=nsp.python_requires,
url=nsp.url,
author=nsp.author,
author_email=nsp.author_email,
cmdclass=cmdclass,
package_dir=nsp.package_dir,
entry_points=nsp.entry_points(),
description=nsp.description,
install_requires=nsp.install_requires,
extras_require=nsp.extras_require, # available since setuptools 18.0 / 2015-06
license=nsp.license,
classifiers=nsp.classifiers,
keywords=nsp.keywords,
package_data=nsp.package_data,
ext_modules=nsp.ext_modules,
test_suite=nsp.test_suite,
)
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 '--record' in sys.argv:
# return
if dump_kw in sys.argv:
sys.argv.remove(dump_kw)
try:
with open('README.rst') as fp:
kw['long_description'] = fp.read()
kw['long_description_content_type'] = 'text/x-rst'
except Exception:
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)
main()
