summaryrefslogtreecommitdiffstats
path: root/setup.py
diff options
context:
space:
mode:
Diffstat (limited to 'setup.py')
-rw-r--r--setup.py917
1 files changed, 917 insertions, 0 deletions
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..b60f159
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,917 @@
+# # header
+# coding: utf-8
+# dd: 20230418
+
+# # __init__.py parser
+
+import sys
+import os
+import datetime
+from textwrap import dedent
+
+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,):
+ open_kw = {}
+else:
+ open_kw = dict(encoding='utf-8') # NOQA: C408
+
+
+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)
+
+if sys.version_info >= (3, 8):
+ from ast import Str, Num, Bytes, NameConstant # NOQA
+
+
+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 {_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 {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)
+ # failed expiriment, see pep 527, new uploads should be tar.gz or .zip
+ # 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_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]
+ # print('d', d, os.getcwd())
+ return d
+
+ 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 = {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.rsplit('.', 1)[-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
+ s = [self._pkg_data['full_package_name']]
+ # 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 = True
+ 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
+ # this used to use distutils
+
+ @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 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
+
+
+class TmpFiles:
+ def __init__(self, pkg_data, py_project=True, keep=False):
+ self._rm_after = []
+ self._pkg_data = pkg_data
+ self._py_project = py_project
+ self._bdist_wheel = 'bdist_wheel' in sys.argv
+ self._keep = keep
+
+ def __enter__(self):
+ self.bdist_wheel()
+ self.py_project()
+
+ def bdist_wheel(self):
+ """pyproject doesn't allow for universal, so use setup.cfg if necessary
+ """
+ file_name = 'setup.cfg'
+ if not self._bdist_wheel or os.path.exists(file_name):
+ return
+ if self._pkg_data.get('universal'):
+ self._rm_after.append(file_name)
+ with open(file_name, 'w') as fp:
+ fp.write('[bdist_wheel]\nuniversal = 1\n')
+
+ def py_project(self):
+ """
+ to prevent pip from complaining, or is it too late to create it from setup.py
+ """
+ file_name = 'pyproject.toml'
+ if not self._py_project or os.path.exists(file_name):
+ return
+ self._rm_after.append(file_name)
+ with open(file_name, 'w') as fp:
+ fp.write(dedent("""\
+ [build-system]
+ requires = ["setuptools", "wheel"]
+ # test
+ build-backend = "setuptools.build_meta"
+ """))
+
+ def __exit__(self, typ, value, traceback):
+ if self._keep:
+ return
+ for p in self._rm_after:
+ if not os.path.exists(p):
+ print('file {} already removed'.format(p))
+ else:
+ os.unlink(p)
+
+
+# call setup
+def main():
+ dump_kw = '--dump-kw'
+ if dump_kw in sys.argv:
+ import wheel
+ import setuptools
+ import pip
+
+ print('python: ', sys.version)
+ print('pip: ', pip.__version__)
+ print('setuptools:', setuptools.__version__)
+ print('wheel: ', wheel.__version__)
+ nsp = NameSpacePackager(pkg_data)
+ nsp.check()
+ # nsp.create_dirs()
+ MySdist.nsp = nsp
+ cmdclass = dict(install_lib=MyInstallLib, sdist=MySdist) # NOQA: C408
+ if _bdist_wheel_available:
+ MyBdistWheel.nsp = nsp
+ cmdclass['bdist_wheel'] = MyBdistWheel
+
+ kw = dict( # NOQA: C408
+ name=nsp.full_package_name,
+ 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,
+ zip_safe=False,
+ )
+
+ 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, repr(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
+ with TmpFiles(pkg_data, keep=True):
+ 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()
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-27 03:17:48 +0000