mercurial: comparison setup.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 # codecs.escape_encode() where it raises SystemError on empty bytestring
 # bug link: https://bugs.python.org/issue25270
 #
 # TODO: when we actually work on Python 3, use this string as the
 # actual supportedpy string.
-supportedpy = ','.join([
+supportedpy = ','.join(
-'>=2.7',
+[
-'!=3.0.*',
+'>=2.7',
-'!=3.1.*',
+'!=3.0.*',
-'!=3.2.*',
+'!=3.1.*',
-'!=3.3.*',
+'!=3.2.*',
-'!=3.4.*',
+'!=3.3.*',
-'!=3.5.0',
+'!=3.4.*',
-'!=3.5.1',
+'!=3.5.0',
-'!=3.5.2',
+'!=3.5.1',
-'!=3.6.0',
+'!=3.5.2',
-'!=3.6.1',
+'!=3.6.0',
-])
+'!=3.6.1',
+]
+)
 import sys, platform
 import sysconfig
 if sys.version_info[0] >= 3:
 printf = eval('print')
 libdir_escape = 'unicode_escape'
 def sysstr(s):
 return s.decode('latin-1')
 else:
 libdir_escape = 'string_escape'
 def printf(*args, **kwargs):
 f = kwargs.get('file', sys.stdout)
 end = kwargs.get('end', '\n')
 f.write(b' '.join(args) + end)
 def sysstr(s):
 return s
 # Attempt to guide users to a modern pip - this means that 2.6 users
 # should have a chance of getting a 4.2 release, and when we ratchet
 # the version requirement forward again hopefully everyone will get
 # something that works for them.
 if sys.version_info < (2, 7, 0, 'final'):
-pip_message = ('This may be due to an out of date pip. '
+pip_message = (
-'Make sure you have pip >= 9.0.1.')
+'This may be due to an out of date pip. '
+'Make sure you have pip >= 9.0.1.'
+)
 try:
 import pip
 pip_version = tuple([int(x) for x in pip.__version__.split('.')[:3]])
-if pip_version < (9, 0, 1) :
+if pip_version < (9, 0, 1):
 pip_message = (
 'Your pip version is out of date, please install '
-'pip >= 9.0.1. pip {} detected.'.format(pip.__version__))
+'pip >= 9.0.1. pip {} detected.'.format(pip.__version__)
+)
 else:
 # pip is new enough - it must be something else
 pip_message = ''
 except Exception:
 pass
 error = """
 Mercurial does not support Python older than 2.7.
 Python {py} detected.
 {pip}
-""".format(py=sys.version_info, pip=pip_message)
+""".format(
+py=sys.version_info, pip=pip_message
+)
 printf(error, file=sys.stderr)
 sys.exit(1)
 # We don't yet officially support Python 3. But we want to allow developers to
 # hack on. Detect and disallow running on Python 3 by default. But provide a
 this command. No special environment variables or configuration changes are
 necessary to run `hg` with Python 3.
 See https://www.mercurial-scm.org/wiki/Python3 for more on Mercurial's
 Python 3 support.
-""".format(py='.'.join('%d' % x for x in sys.version_info[0:2]))
+""".format(
+py='.'.join('%d' % x for x in sys.version_info[0:2])
+)
 printf(error, file=sys.stderr)
 sys.exit(1)
 if sys.version_info[0] >= 3:
 DYLIB_SUFFIX = sysconfig.get_config_vars()['SO']
 # Solaris Python packaging brain damage
 try:
 import hashlib
 sha = hashlib.sha1()
 except ImportError:
 try:
 import sha
-sha.sha # silence unused import warning
+sha.sha  # silence unused import warning
 except ImportError:
 raise SystemExit(
-"Couldn't import standard hashlib (incomplete Python install).")
+"Couldn't import standard hashlib (incomplete Python install)."
+)
 try:
 import zlib
-zlib.compressobj # silence unused import warning
+zlib.compressobj  # silence unused import warning
 except ImportError:
 raise SystemExit(
-"Couldn't import standard zlib (incomplete Python install).")
+"Couldn't import standard zlib (incomplete Python install)."
+)
 # The base IronPython distribution (as of 2.7.1) doesn't support bz2
 isironpython = False
 try:
-isironpython = (platform.python_implementation()
+isironpython = (
-.lower().find("ironpython") != -1)
+platform.python_implementation().lower().find("ironpython") != -1
+)
 except AttributeError:
 pass
 if isironpython:
 sys.stderr.write("warning: IronPython detected (no bz2 support)\n")
 else:
 try:
 import bz2
-bz2.BZ2Compressor # silence unused import warning
+bz2.BZ2Compressor  # silence unused import warning
 except ImportError:
 raise SystemExit(
-"Couldn't import standard bz2 (incomplete Python install).")
+"Couldn't import standard bz2 (incomplete Python install)."
+)
 ispypy = "PyPy" in sys.version
 hgrustext = os.environ.get('HGWITHRUSTEXT')
 # TODO record it for proper rebuild upon changes
 import stat, subprocess, time
 import re
 import shutil
 import tempfile
 from distutils import log
 # We have issues with setuptools on some platforms and builders. Until
 # those are resolved, setuptools is opt-in except for platforms where
 # we don't have issues.
-issetuptools = (os.name == 'nt' or 'FORCE_SETUPTOOLS' in os.environ)
+issetuptools = os.name == 'nt' or 'FORCE_SETUPTOOLS' in os.environ
 if issetuptools:
 from setuptools import setup
 else:
 from distutils.core import setup
 from distutils.ccompiler import new_compiler
 from distutils.version import StrictVersion
 # Explain to distutils.StrictVersion how our release candidates are versionned
 StrictVersion.version_re = re.compile(r'^(\d+)\.(\d+)(\.(\d+))?-?(rc(\d+))?$')
 def write_if_changed(path, content):
 """Write content to a file iff the content hasn't changed."""
 if os.path.exists(path):
 with open(path, 'rb') as fh:
 current = fh.read()
 if current != content:
 with open(path, 'wb') as fh:
 fh.write(content)
 scripts = ['hg']
 if os.name == 'nt':
 # We remove hg.bat if we are able to build hg.exe.
 scripts.append('contrib/win32/hg.bat')
 def cancompile(cc, code):
 tmpdir = tempfile.mkdtemp(prefix='hg-install-')
 devnull = oldstderr = None
 try:
 os.dup2(oldstderr, sys.stderr.fileno())
 if devnull is not None:
 devnull.close()
 shutil.rmtree(tmpdir)
 # simplified version of distutils.ccompiler.CCompiler.has_function
 # that actually removes its temporary files.
 def hasfunction(cc, funcname):
 code = 'int main(void) { %s(); }\n' % funcname
 return cancompile(cc, code)
 def hasheader(cc, headername):
 code = '#include <%s>\nint main(void) { return 0; }\n' % headername
 return cancompile(cc, code)
 # py2exe needs to be installed to work
 try:
 import py2exe
-py2exe.Distribution # silence unused import warning
+py2exe.Distribution  # silence unused import warning
 py2exeloaded = True
 # import py2exe's patched Distribution class
 from distutils.core import Distribution
 except ImportError:
 py2exeloaded = False
 def runcmd(cmd, env, cwd=None):
-p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+p = subprocess.Popen(
-stderr=subprocess.PIPE, env=env, cwd=cwd)
+cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env, cwd=cwd
+)
 out, err = p.communicate()
 return p.returncode, out, err
 class hgcommand(object):
 def __init__(self, cmd, env):
 self.cmd = cmd
 self.env = env
 printf("stderr from '%s':" % (' '.join(cmd)), file=sys.stderr)
 printf(err, file=sys.stderr)
 return ''
 return out
 def filterhgerr(err):
 # If root is executing setup.py, but the repository is owned by
 # another user (as in "sudo python setup.py install") we will get
 # trust warnings since the .hg/hgrc file is untrusted. That is
 # fine, we don't want to load it anyway.  Python may warn about
 # a missing __init__.py in mercurial/locale, we also ignore that.
-err = [e for e in err.splitlines()
+err = [
-if (not e.startswith(b'not trusting file')
+e
-and not e.startswith(b'warning: Not importing')
+for e in err.splitlines()
-and not e.startswith(b'obsolete feature not enabled')
+if (
-and not e.startswith(b'*** failed to import extension')
+not e.startswith(b'not trusting file')
-and not e.startswith(b'devel-warn:')
+and not e.startswith(b'warning: Not importing')
-and not (e.startswith(b'(third party extension')
+and not e.startswith(b'obsolete feature not enabled')
-and e.endswith(b'or newer of Mercurial; disabling)')))]
+and not e.startswith(b'*** failed to import extension')
+and not e.startswith(b'devel-warn:')
+and not (
+e.startswith(b'(third party extension')
+and e.endswith(b'or newer of Mercurial; disabling)')
+)
+)
+]
 return b'\n'.join(b'  ' + e for e in err)
 def findhg():
 """Try to figure out how we should invoke hg for examining the local
 repository contents.
 except EnvironmentError:
 retcode = -1
 if retcode == 0 and not filterhgerr(err):
 return hgcommand(hgcmd, hgenv)
-raise SystemExit('Unable to find a working hg binary to extract the '
+raise SystemExit(
-'version from the repository tags')
+'Unable to find a working hg binary to extract the '
+'version from the repository tags'
+)
 def localhgenv():
 """Get an environment dictionary to use for invoking or importing
 mercurial from the local repository."""
 # Execute hg out of this directory with a custom environment which takes
 # care to not use any hgrc files and do no localization.
-env = {'HGMODULEPOLICY': 'py',
+env = {
-'HGRCPATH': '',
+'HGMODULEPOLICY': 'py',
-'LANGUAGE': 'C',
+'HGRCPATH': '',
-'PATH': ''} # make pypi modules that use os.environ['PATH'] happy
+'LANGUAGE': 'C',
+'PATH': '',
+}  # make pypi modules that use os.environ['PATH'] happy
 if 'LD_LIBRARY_PATH' in os.environ:
 env['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
 if 'SystemRoot' in os.environ:
 # SystemRoot is required by Windows to load various DLLs.  See:
 # https://bugs.python.org/issue13524#msg148850
 env['SystemRoot'] = os.environ['SystemRoot']
 return env
 version = ''
 if os.path.isdir('.hg'):
 hg = findhg()
 # Bail out if hg is having problems interacting with this repository,
 # rather than falling through and producing a bogus version number.
 # Continuing with an invalid version number will break extensions
 # that define minimumhgversion.
 raise SystemExit('Unable to determine hg version from local repository')
-if numerictags: # tag(s) found
+if numerictags:  # tag(s) found
 version = numerictags[-1]
-if hgid.endswith('+'): # propagate the dirty status to the tag
+if hgid.endswith('+'):  # propagate the dirty status to the tag
 version += '+'
-else: # no tag found
+else:  # no tag found
 ltagcmd = ['parents', '--template', '{latesttag}']
 ltag = sysstr(hg.run(ltagcmd))
 changessincecmd = ['log', '-T', 'x\n', '-r', "only(.,'%s')" % ltag]
 changessince = len(hg.run(changessincecmd).splitlines())
 version = '%s+%s-%s' % (ltag, changessince, hgid)
 if version.endswith('+'):
 version += time.strftime('%Y%m%d')
 elif os.path.exists('.hg_archival.txt'):
-kw = dict([[t.strip() for t in l.split(':', 1)]
+kw = dict(
-for l in open('.hg_archival.txt')])
+[[t.strip() for t in l.split(':', 1)] for l in open('.hg_archival.txt')]
+)
 if 'tag' in kw:
 version = kw['tag']
 elif 'latesttag' in kw:
 if 'changessincelatesttag' in kw:
 version = '%(latesttag)s+%(changessincelatesttag)s-%(node).12s' % kw
 if version:
 versionb = version
 if not isinstance(versionb, bytes):
 versionb = versionb.encode('ascii')
-write_if_changed('mercurial/__version__.py', b''.join([
+write_if_changed(
-b'# this file is autogenerated by setup.py\n'
+'mercurial/__version__.py',
-b'version = b"%s"\n' % versionb,
+b''.join(
-]))
+[
+b'# this file is autogenerated by setup.py\n'
+b'version = b"%s"\n' % versionb,
+]
+),
+)
 try:
 oldpolicy = os.environ.get('HGMODULEPOLICY', None)
 os.environ['HGMODULEPOLICY'] = 'py'
 from mercurial import __version__
 version = __version__.version
 except ImportError:
 version = b'unknown'
 finally:
 if oldpolicy is None:
 del os.environ['HGMODULEPOLICY']
 else:
 os.environ['HGMODULEPOLICY'] = oldpolicy
 class hgbuild(build):
 # Insert hgbuildmo first so that files in mercurial/locale/ are found
 # when build_py is run next.
 sub_commands = [('build_mo', None)] + build.sub_commands
 class hgbuildmo(build):
 description = "build translations (.mo files)"
 def run(self):
 if not find_executable('msgfmt'):
-self.warn("could not find msgfmt executable, no translations "
+self.warn(
-"will be built")
+"could not find msgfmt executable, no translations "
+"will be built"
+)
 return
 podir = 'i18n'
 if not os.path.isdir(podir):
 self.warn("could not find %s/ directory" % podir)
 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)
 # This is ugly as a one-liner. So use a variable.
 buildextnegops = dict(getattr(build_ext, 'negative_options', {}))
 buildextnegops['no-zstd'] = 'zstd'
 buildextnegops['no-rust'] = 'rust'
 class hgbuildext(build_ext):
 user_options = build_ext.user_options + [
 ('zstd', None, 'compile zstd bindings [default]'),
 ('no-zstd', None, 'do not compile zstd bindings'),
-('rust', None,
+(
-'compile Rust extensions if they are in use '
+'rust',
-'(requires Cargo) [default]'),
+None,
+'compile Rust extensions if they are in use '
+'(requires Cargo) [default]',
+),
 ('no-rust', None, 'do not compile Rust extensions'),
 ]
 boolean_options = build_ext.boolean_options + ['zstd', 'rust']
 negative_opt = buildextnegops
 self.parallel = True
 return build_ext.finalize_options(self)
 def build_extensions(self):
-ruststandalones = [e for e in self.extensions
+ruststandalones = [
-if isinstance(e, RustStandaloneExtension)]
+e for e in self.extensions if isinstance(e, RustStandaloneExtension)
-self.extensions = [e for e in self.extensions
+]
-if e not in ruststandalones]
+self.extensions = [
+e for e in self.extensions if e not in ruststandalones
+]
 # Filter out zstd if disabled via argument.
 if not self.zstd:
-self.extensions = [e for e in self.extensions
+self.extensions = [
-if e.name != 'mercurial.zstd']
+e for e in self.extensions if e.name != 'mercurial.zstd'
+]
 # Build Rust standalon extensions if it'll be used
 # and its build is not explictely disabled (for external build
 # as Linux distributions would do)
 if self.distribution.rust and self.rust and hgrustext != 'direct-ffi':
 rustext.build('' if self.inplace else self.build_lib)
 return build_ext.build_extensions(self)
 def build_extension(self, ext):
-if (self.distribution.rust and self.rust
+if (
-and isinstance(ext, RustExtension)):
+self.distribution.rust
-ext.rustbuild()
+and self.rust
+and isinstance(ext, RustExtension)
+):
+ext.rustbuild()
 try:
 build_ext.build_extension(self, ext)
 except CCompilerError:
 if not getattr(ext, 'optional', False):
 raise
-log.warn("Failed to build optional extension '%s' (skipping)",
+log.warn(
-ext.name)
+"Failed to build optional extension '%s' (skipping)", ext.name
+)
 class hgbuildscripts(build_scripts):
 def run(self):
 if os.name != 'nt' or self.distribution.pure:
 return build_scripts.run(self)
 # Remove hg.bat because it is redundant with hg.exe.
 self.scripts.remove('contrib/win32/hg.bat')
 return build_scripts.run(self)
 class hgbuildpy(build_py):
 def finalize_options(self):
 build_py.finalize_options(self)
 if self.distribution.pure:
 elif self.distribution.cffi:
 from mercurial.cffi import (
 bdiffbuild,
 mpatchbuild,
 )
-exts = [mpatchbuild.ffi.distutils_extension(),
-bdiffbuild.ffi.distutils_extension()]
+exts = [
+mpatchbuild.ffi.distutils_extension(),
+bdiffbuild.ffi.distutils_extension(),
+]
 # cffi modules go here
 if sys.platform == 'darwin':
 from mercurial.cffi import osutilbuild
 exts.append(osutilbuild.ffi.distutils_extension())
 self.distribution.ext_modules = exts
 else:
 h = os.path.join(get_python_inc(), 'Python.h')
 if not os.path.exists(h):
-raise SystemExit('Python headers are required to build '
+raise SystemExit(
-'Mercurial but weren\'t found in %s' % h)
+'Python headers are required to build '
+'Mercurial but weren\'t found in %s' % h
+)
 def run(self):
 basepath = os.path.join(self.build_lib, 'mercurial')
 self.mkpath(basepath)
 # in-place build should run without rebuilding and Rust extensions
 modulepolicy = 'rust+c-allow' if rust else 'allow'
 else:
 modulepolicy = 'rust+c' if rust else 'c'
-content = b''.join([
+content = b''.join(
-b'# this file is autogenerated by setup.py\n',
+[
-b'modulepolicy = b"%s"\n' % modulepolicy.encode('ascii'),
+b'# this file is autogenerated by setup.py\n',
-])
+b'modulepolicy = b"%s"\n' % modulepolicy.encode('ascii'),
-write_if_changed(os.path.join(basepath, '__modulepolicy__.py'),
+]
-content)
+)
+write_if_changed(os.path.join(basepath, '__modulepolicy__.py'), content)
 build_py.run(self)
 class buildhgextindex(Command):
 description = 'generate prebuilt index of hgext (for frozen package)'
 user_options = []
 _indexfilename = 'hgext/__index__.py'
 if os.path.exists(self._indexfilename):
 with open(self._indexfilename, 'w') as f:
 f.write('# empty\n')
 # here no extension enabled, disabled() lists up everything
-code = ('import pprint; from mercurial import extensions; '
+code = (
-'pprint.pprint(extensions.disabled())')
+'import pprint; from mercurial import extensions; '
-returncode, out, err = runcmd([sys.executable, '-c', code],
+'pprint.pprint(extensions.disabled())'
-localhgenv())
+)
+returncode, out, err = runcmd(
+[sys.executable, '-c', code], localhgenv()
+)
 if err or returncode != 0:
 raise DistutilsExecError(err)
 with open(self._indexfilename, 'wb') as f:
 f.write(b'# this file is autogenerated by setup.py\n')
 f.write(b'docs = ')
 f.write(out)
 class buildhgexe(build_ext):
 description = 'compile hg.exe from mercurial/exewrapper.c'
 user_options = build_ext.user_options + [
-('long-paths-support', None, 'enable support for long paths on '
+(
-'Windows (off by default and '
+'long-paths-support',
-'experimental)'),
+None,
+'enable support for long paths on '
+'Windows (off by default and '
+'experimental)',
+),
 ]
 LONG_PATHS_MANIFEST = """
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
 def build_extensions(self):
 if os.name != 'nt':
 return
 if isinstance(self.compiler, HackedMingw32CCompiler):
-self.compiler.compiler_so = self.compiler.compiler # no -mdll
+self.compiler.compiler_so = self.compiler.compiler  # no -mdll
-self.compiler.dll_libraries = [] # no -lmsrvc90
+self.compiler.dll_libraries = []  # no -lmsrvc90
 # Different Python installs can have different Python library
 # names. e.g. the official CPython distribution uses pythonXY.dll
 # and MinGW uses libpythonX.Y.dll.
 _kernel32 = ctypes.windll.kernel32
-_kernel32.GetModuleFileNameA.argtypes = [ctypes.c_void_p,
+_kernel32.GetModuleFileNameA.argtypes = [
 ctypes.c_void_p,
-ctypes.c_ulong]
+ctypes.c_void_p,
+ctypes.c_ulong,
+]
 _kernel32.GetModuleFileNameA.restype = ctypes.c_ulong
 size = 1000
 buf = ctypes.create_string_buffer(size + 1)
-filelen = _kernel32.GetModuleFileNameA(sys.dllhandle, ctypes.byref(buf),
+filelen = _kernel32.GetModuleFileNameA(
-size)
+sys.dllhandle, ctypes.byref(buf), size
+)
 if filelen > 0 and filelen != size:
 dllbasename = os.path.basename(buf.value)
 if not dllbasename.lower().endswith(b'.dll'):
-raise SystemExit('Python DLL does not end with .dll: %s' %
+raise SystemExit(
-dllbasename)
+'Python DLL does not end with .dll: %s' % dllbasename
+)
 pythonlib = dllbasename[:-4]
 else:
-log.warn('could not determine Python DLL filename; '
+log.warn(
-'assuming pythonXY')
+'could not determine Python DLL filename; ' 'assuming pythonXY'
+)
 hv = sys.hexversion
-pythonlib = 'python%d%d' % (hv >> 24, (hv >> 16) & 0xff)
+pythonlib = 'python%d%d' % (hv >> 24, (hv >> 16) & 0xFF)
 log.info('using %s as Python library name' % pythonlib)
 with open('mercurial/hgpythonlib.h', 'wb') as f:
 f.write(b'/* this file is autogenerated by setup.py */\n')
 f.write(b'#define HGPYTHONLIB "%s"\n' % pythonlib)
 macros = None
 if sys.version_info[0] >= 3:
 macros = [('_UNICODE', None), ('UNICODE', None)]
-objects = self.compiler.compile(['mercurial/exewrapper.c'],
+objects = self.compiler.compile(
-output_dir=self.build_temp,
+['mercurial/exewrapper.c'],
-macros=macros)
+output_dir=self.build_temp,
+macros=macros,
+)
 dir = os.path.dirname(self.get_ext_fullpath('dummy'))
 self.hgtarget = os.path.join(dir, 'hg')
-self.compiler.link_executable(objects, self.hgtarget,
+self.compiler.link_executable(
-libraries=[],
+objects, self.hgtarget, libraries=[], output_dir=self.build_temp
-output_dir=self.build_temp)
+)
 if self.long_paths_support:
 self.addlongpathsmanifest()
 def addlongpathsmanifest(self):
 r"""Add manifest pieces so that hg.exe understands long paths
 inputresource = '-inputresource:%s;#1' % exefname
 outputresource = '-outputresource:%s;#1' % exefname
 log.info("running mt.exe to update hg.exe's manifest in-place")
 # supplying both -manifest and -inputresource to mt.exe makes
 # it merge the embedded and supplied manifests in the -outputresource
-self.spawn(['mt.exe', '-nologo', '-manifest', manfname,
+self.spawn(
-inputresource, outputresource])
+[
+'mt.exe',
+'-nologo',
+'-manifest',
+manfname,
+inputresource,
+outputresource,
+]
+)
 log.info("done updating hg.exe's manifest")
 os.remove(manfname)
 @property
 def hgexepath(self):
 dir = os.path.dirname(self.get_ext_fullpath('dummy'))
 return os.path.join(self.build_temp, dir, 'hg.exe')
 class hgbuilddoc(Command):
 description = 'build documentation'
 user_options = [
 ('man', None, 'generate man pages'),
 def gentxt(root):
 txt = 'doc/%s.txt' % root
 log.info('generating %s' % txt)
 res, out, err = runcmd(
-[sys.executable, 'gendoc.py', root],
+[sys.executable, 'gendoc.py', root], os.environ, cwd='doc'
-os.environ,
+)
-cwd='doc')
 if res:
-raise SystemExit('error running gendoc.py: %s' %
+raise SystemExit(
-'\n'.join([out, err]))
+'error running gendoc.py: %s' % '\n'.join([out, err])
+)
 with open(txt, 'wb') as fh:
 fh.write(out)
 def gengendoc(root):
 log.info('generating %s' % gendoc)
 res, out, err = runcmd(
 [sys.executable, 'gendoc.py', '%s.gendoc' % root],
 os.environ,
-cwd='doc')
+cwd='doc',
+)
 if res:
-raise SystemExit('error running gendoc: %s' %
+raise SystemExit(
-'\n'.join([out, err]))
+'error running gendoc: %s' % '\n'.join([out, err])
+)
 with open(gendoc, 'wb') as fh:
 fh.write(out)
 def genman(root):
 log.info('generating doc/%s' % root)
 res, out, err = runcmd(
-[sys.executable, 'runrst', 'hgmanpage', '--halt', 'warning',
+[
-'--strip-elements-with-class', 'htmlonly',
+sys.executable,
-'%s.txt' % root, root],
+'runrst',
+'hgmanpage',
+'--halt',
+'warning',
+'--strip-elements-with-class',
+'htmlonly',
+'%s.txt' % root,
+root,
+],
 os.environ,
-cwd='doc')
+cwd='doc',
+)
 if res:
-raise SystemExit('error running runrst: %s' %
+raise SystemExit(
-'\n'.join([out, err]))
+'error running runrst: %s' % '\n'.join([out, err])
+)
 normalizecrlf('doc/%s' % root)
 def genhtml(root):
 log.info('generating doc/%s.html' % root)
 res, out, err = runcmd(
-[sys.executable, 'runrst', 'html', '--halt', 'warning',
+[
-'--link-stylesheet', '--stylesheet-path', 'style.css',
+sys.executable,
-'%s.txt' % root, '%s.html' % root],
+'runrst',
+'html',
+'--halt',
+'warning',
+'--link-stylesheet',
+'--stylesheet-path',
+'style.css',
+'%s.txt' % root,
+'%s.html' % root,
+],
 os.environ,
-cwd='doc')
+cwd='doc',
+)
 if res:
-raise SystemExit('error running runrst: %s' %
+raise SystemExit(
-'\n'.join([out, err]))
+'error running runrst: %s' % '\n'.join([out, err])
+)
 normalizecrlf('doc/%s.html' % root)
 # This logic is duplicated in doc/Makefile.
-sources = set(f for f in os.listdir('mercurial/help')
+sources = set(
-if re.search(r'[0-9]\.txt$', f))
+f
+for f in os.listdir('mercurial/help')
+if re.search(r'[0-9]\.txt$', f)
+)
 # common.txt is a one-off.
 gentxt('common')
 for source in sorted(sources):
 if self.man:
 genman(root)
 if self.html:
 genhtml(root)
 class hginstall(install):
 user_options = install.user_options + [
-('old-and-unmanageable', None,
+(
-'noop, present for eggless setuptools compat'),
+'old-and-unmanageable',
-('single-version-externally-managed', None,
+None,
-'noop, present for eggless setuptools compat'),
+'noop, present for eggless setuptools compat',
+),
+(
+'single-version-externally-managed',
+None,
+'noop, present for eggless setuptools compat',
+),
 ]
 # Also helps setuptools not be sad while we refuse to create eggs.
 single_version_externally_managed = True
 # Screen out egg related commands to prevent egg generation.  But allow
 # mercurial.egg-info generation, since that is part of modern
 # packaging.
 excl = set(['bdist_egg'])
 return filter(lambda x: x not in excl, install.get_sub_commands(self))
 class hginstalllib(install_lib):
 '''
 This is a specialization of install_lib that replaces the copy_file used
 there so that it supports setting the mode of files after copying them,
 insufficient, as it might still be applying a umask.
 '''
 def run(self):
 realcopyfile = file_util.copy_file
 def copyfileandsetmode(*args, **kwargs):
 src, dst = args[0], args[1]
 dst, copied = realcopyfile(*args, **kwargs)
 if copied:
 st = os.stat(src)
 else:
 setmode = int('0644', 8)
 m = stat.S_IMODE(st[stat.ST_MODE])
 m = (m & ~int('0777', 8)) | setmode
 os.chmod(dst, m)
 file_util.copy_file = copyfileandsetmode
 try:
 install_lib.run(self)
 finally:
 file_util.copy_file = realcopyfile
 class hginstallscripts(install_scripts):
 '''
 This is a specialization of install_scripts that replaces the @LIBDIR@ with
 the configured directory for modules. If possible, the path is made relative
 self.install_lib = None
 def finalize_options(self):
 install_scripts.finalize_options(self)
-self.set_undefined_options('install',
+self.set_undefined_options('install', ('install_lib', 'install_lib'))
-('install_lib', 'install_lib'))
 def run(self):
 install_scripts.run(self)
 # It only makes sense to replace @LIBDIR@ with the install path if
 # will be. And, wheels don't appear to provide the ability to register
 # custom code to run during wheel installation. This all means that
 # we can't reliably set the libdir in wheels: the default behavior
 # of looking in sys.path must do.
-if (os.path.splitdrive(self.install_dir)[0] !=
+if (
-os.path.splitdrive(self.install_lib)[0]):
+os.path.splitdrive(self.install_dir)[0]
+!= os.path.splitdrive(self.install_lib)[0]
+):
 # can't make relative paths from one drive to another, so use an
 # absolute path instead
 libdir = self.install_lib
 else:
 common = os.path.commonprefix((self.install_dir, self.install_lib))
-rest = self.install_dir[len(common):]
+rest = self.install_dir[len(common) :]
 uplevel = len([n for n in os.path.split(rest) if n])
-libdir = uplevel * ('..' + os.sep) + self.install_lib[len(common):]
+libdir = uplevel * ('..' + os.sep) + self.install_lib[len(common) :]
 for outfile in self.outfiles:
 with open(outfile, 'rb') as fp:
 data = fp.read()
 # During local installs, the shebang will be rewritten to the final
 # install path. During wheel packaging, the shebang has a special
 # value.
 if data.startswith(b'#!python'):
-log.info('not rewriting @LIBDIR@ in %s because install path '
+log.info(
-'not known' % outfile)
+'not rewriting @LIBDIR@ in %s because install path '
+'not known' % outfile
+)
 continue
 data = data.replace(b'@LIBDIR@', libdir.encode(libdir_escape))
 with open(outfile, 'wb') as fp:
 fp.write(data)
 # virtualenv installs custom distutils/__init__.py and
 # distutils/distutils.cfg files which essentially proxy back to the
 # "real" distutils in the main Python install. The presence of this
 # directory causes py2exe to pick up the "hacked" distutils package
 modules[k] = v
 res.modules = modules
 import opcode
-distutilsreal = os.path.join(os.path.dirname(opcode.__file__),
-'distutils')
+distutilsreal = os.path.join(
+os.path.dirname(opcode.__file__), 'distutils'
+)
 for root, dirs, files in os.walk(distutilsreal):
 for f in sorted(files):
 if not f.endswith('.py'):
 continue
 if modname.startswith('distutils.tests.'):
 continue
 if modname.endswith('.__init__'):
-modname = modname[:-len('.__init__')]
+modname = modname[: -len('.__init__')]
 path = os.path.dirname(full)
 else:
 path = None
-res.modules[modname] = py2exemodule(modname, full,
+res.modules[modname] = py2exemodule(
-path=path)
+modname, full, path=path
+)
 if 'distutils' not in res.modules:
 raise SystemExit('could not find distutils modules')
 return res
-cmdclass = {'build': hgbuild,
-'build_doc': hgbuilddoc,
+cmdclass = {
-'build_mo': hgbuildmo,
+'build': hgbuild,
-'build_ext': hgbuildext,
+'build_doc': hgbuilddoc,
-'build_py': hgbuildpy,
+'build_mo': hgbuildmo,
-'build_scripts': hgbuildscripts,
+'build_ext': hgbuildext,
-'build_hgextindex': buildhgextindex,
+'build_py': hgbuildpy,
-'install': hginstall,
+'build_scripts': hgbuildscripts,
-'install_lib': hginstalllib,
+'build_hgextindex': buildhgextindex,
-'install_scripts': hginstallscripts,
+'install': hginstall,
-'build_hgexe': buildhgexe,
+'install_lib': hginstalllib,
-}
+'install_scripts': hginstallscripts,
+'build_hgexe': buildhgexe,
+}
 if py2exehacked:
 cmdclass['py2exe'] = hgbuildpy2exe
-packages = ['mercurial',
+packages = [
-'mercurial.cext',
+'mercurial',
-'mercurial.cffi',
+'mercurial.cext',
-'mercurial.hgweb',
+'mercurial.cffi',
-'mercurial.interfaces',
+'mercurial.hgweb',
-'mercurial.pure',
+'mercurial.interfaces',
-'mercurial.thirdparty',
+'mercurial.pure',
-'mercurial.thirdparty.attr',
+'mercurial.thirdparty',
-'mercurial.thirdparty.zope',
+'mercurial.thirdparty.attr',
-'mercurial.thirdparty.zope.interface',
+'mercurial.thirdparty.zope',
-'mercurial.utils',
+'mercurial.thirdparty.zope.interface',
-'mercurial.revlogutils',
+'mercurial.utils',
-'mercurial.testing',
+'mercurial.revlogutils',
-'hgext', 'hgext.convert', 'hgext.fsmonitor',
+'mercurial.testing',
-'hgext.fastannotate',
+'hgext',
-'hgext.fsmonitor.pywatchman',
+'hgext.convert',
-'hgext.highlight',
+'hgext.fsmonitor',
-'hgext.infinitepush',
+'hgext.fastannotate',
-'hgext.largefiles', 'hgext.lfs', 'hgext.narrow',
+'hgext.fsmonitor.pywatchman',
-'hgext.remotefilelog',
+'hgext.highlight',
-'hgext.zeroconf', 'hgext3rd',
+'hgext.infinitepush',
-'hgdemandimport']
+'hgext.largefiles',
+'hgext.lfs',
+'hgext.narrow',
+'hgext.remotefilelog',
+'hgext.zeroconf',
+'hgext3rd',
+'hgdemandimport',
+]
 if sys.version_info[0] == 2:
-packages.extend(['mercurial.thirdparty.concurrent',
+packages.extend(
-'mercurial.thirdparty.concurrent.futures'])
+[
+'mercurial.thirdparty.concurrent',
+'mercurial.thirdparty.concurrent.futures',
+]
+)
 if 'HG_PY2EXE_EXTRA_INSTALL_PACKAGES' in os.environ:
 # py2exe can't cope with namespace packages very well, so we have to
 # install any hgext3rd.* extensions that we want in the final py2exe
 # image here. This is gross, but you gotta do what you gotta do.
 packages.extend(os.environ['HG_PY2EXE_EXTRA_INSTALL_PACKAGES'].split(' '))
-common_depends = ['mercurial/bitmanipulation.h',
+common_depends = [
-'mercurial/compat.h',
+'mercurial/bitmanipulation.h',
-'mercurial/cext/util.h']
+'mercurial/compat.h',
+'mercurial/cext/util.h',
+]
 common_include_dirs = ['mercurial']
 osutil_cflags = []
 osutil_ldflags = []
 for plat, func in [('bsd', 'setproctitle')]:
 if re.search(plat, sys.platform) and hasfunction(new_compiler(), func):
 osutil_cflags.append('-DHAVE_%s' % func.upper())
 for plat, macro, code in [
-('bsd|darwin', 'BSD_STATFS', '''
+(
+'bsd|darwin',
+'BSD_STATFS',
+'''
 #include <sys/param.h>
 #include <sys/mount.h>
 int main() { struct statfs s; return sizeof(s.f_fstypename); }
-'''),
+''',
-('linux', 'LINUX_STATFS', '''
+),
+(
+'linux',
+'LINUX_STATFS',
+'''
 #include <linux/magic.h>
 #include <sys/vfs.h>
 int main() { struct statfs s; return sizeof(s.f_type); }
-'''),
+''',
+),
 ]:
 if re.search(plat, sys.platform) and cancompile(new_compiler(), code):
 osutil_cflags.append('-DHAVE_%s' % macro)
 if sys.platform == 'darwin':
 'mercurial/thirdparty/xdiff/xprepare.h',
 'mercurial/thirdparty/xdiff/xtypes.h',
 'mercurial/thirdparty/xdiff/xutils.h',
 ]
 class RustCompilationError(CCompilerError):
 """Exception class for Rust compilation errors."""
 class RustExtension(Extension):
 """Base classes for concrete Rust Extension classes.
 """
 rusttargetdir = os.path.join('rust', 'target', 'release')
-def __init__(self, mpath, sources, rustlibname, subcrate,
+def __init__(
-py3_features=None, **kw):
+self, mpath, sources, rustlibname, subcrate, py3_features=None, **kw
+):
 Extension.__init__(self, mpath, sources, **kw)
 srcdir = self.rustsrcdir = os.path.join('rust', subcrate)
 self.py3_features = py3_features
 # adding Rust source and control files to depends so that the extension
 self.depends.append(os.path.join(srcdir, 'Cargo.toml'))
 cargo_lock = os.path.join(srcdir, 'Cargo.lock')
 if os.path.exists(cargo_lock):
 self.depends.append(cargo_lock)
 for dirpath, subdir, fnames in os.walk(os.path.join(srcdir, 'src')):
-self.depends.extend(os.path.join(dirpath, fname)
+self.depends.extend(
-for fname in fnames
+os.path.join(dirpath, fname)
-if os.path.splitext(fname)[1] == '.rs')
+for fname in fnames
+if os.path.splitext(fname)[1] == '.rs'
+)
 @staticmethod
 def rustdylibsuffix():
 """Return the suffix for shared libraries produced by rustc.
 # invoke this build.
 # Unix only fix (os.path.expanduser not really reliable if
 # HOME is shadowed like this)
 import pwd
 env['HOME'] = pwd.getpwuid(os.getuid()).pw_dir
 cargocmd = ['cargo', 'rustc', '-vv', '--release']
 if sys.version_info[0] == 3 and self.py3_features is not None:
-cargocmd.extend(('--features', self.py3_features,
+cargocmd.extend(
-'--no-default-features'))
+('--features', self.py3_features, '--no-default-features')
+)
 cargocmd.append('--')
 if sys.platform == 'darwin':
-cargocmd.extend(("-C", "link-arg=-undefined",
+cargocmd.extend(
-"-C", "link-arg=dynamic_lookup"))
+("-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup")
+)
 try:
 subprocess.check_call(cargocmd, env=env, cwd=self.rustsrcdir)
 except OSError as exc:
 if exc.errno == errno.ENOENT:
 raise RustCompilationError("Cargo not found")
 elif exc.errno == errno.EACCES:
 raise RustCompilationError(
-"Cargo found, but permisssion to execute it is denied")
+"Cargo found, but permisssion to execute it is denied"
+)
 else:
 raise
 except subprocess.CalledProcessError:
 raise RustCompilationError(
 "Cargo failed. Working directory: %r, "
 "command: %r, environment: %r"
-% (self.rustsrcdir, cargocmd, env))
+% (self.rustsrcdir, cargocmd, env)
+)
 class RustEnhancedExtension(RustExtension):
 """A C Extension, conditionally enhanced with Rust code.
 If the HGRUSTEXT environment variable is set to something else
 than 'cpython', the Rust sources get compiled and linked within the
 C target shared library object.
 """
 def __init__(self, mpath, sources, rustlibname, subcrate, **kw):
-RustExtension.__init__(self, mpath, sources, rustlibname, subcrate,
+RustExtension.__init__(
-**kw)
+self, mpath, sources, rustlibname, subcrate, **kw
+)
 if hgrustext != 'direct-ffi':
 return
 self.extra_compile_args.append('-DWITH_RUST')
 self.libraries.append(rustlibname)
 self.library_dirs.append(self.rusttargetdir)
 def rustbuild(self):
 if hgrustext == 'direct-ffi':
 RustExtension.rustbuild(self)
 class RustStandaloneExtension(RustExtension):
 def __init__(self, pydottedname, rustcrate, dylibname, **kw):
-RustExtension.__init__(self, pydottedname, [], dylibname, rustcrate,
+RustExtension.__init__(
-**kw)
+self, pydottedname, [], dylibname, rustcrate, **kw
+)
 self.dylibname = dylibname
 def build(self, target_dir):
 self.rustbuild()
 target = [target_dir]
 target.extend(self.name.split('.'))
 target[-1] += DYLIB_SUFFIX
-shutil.copy2(os.path.join(self.rusttargetdir,
+shutil.copy2(
-self.dylibname + self.rustdylibsuffix()),
+os.path.join(
-os.path.join(*target))
+self.rusttargetdir, self.dylibname + self.rustdylibsuffix()
+),
+os.path.join(*target),
+)
 extmodules = [
-Extension('mercurial.cext.base85', ['mercurial/cext/base85.c'],
+Extension(
-include_dirs=common_include_dirs,
+'mercurial.cext.base85',
-depends=common_depends),
+['mercurial/cext/base85.c'],
-Extension('mercurial.cext.bdiff', ['mercurial/bdiff.c',
+include_dirs=common_include_dirs,
-'mercurial/cext/bdiff.c'] + xdiff_srcs,
+depends=common_depends,
-include_dirs=common_include_dirs,
+),
-depends=common_depends + ['mercurial/bdiff.h'] + xdiff_headers),
+Extension(
-Extension('mercurial.cext.mpatch', ['mercurial/mpatch.c',
+'mercurial.cext.bdiff',
-'mercurial/cext/mpatch.c'],
+['mercurial/bdiff.c', 'mercurial/cext/bdiff.c'] + xdiff_srcs,
 include_dirs=common_include_dirs,
-depends=common_depends),
+depends=common_depends + ['mercurial/bdiff.h'] + xdiff_headers,
+),
+Extension(
+'mercurial.cext.mpatch',
+['mercurial/mpatch.c', 'mercurial/cext/mpatch.c'],
+include_dirs=common_include_dirs,
+depends=common_depends,
+),
 RustEnhancedExtension(
-'mercurial.cext.parsers', ['mercurial/cext/charencode.c',
+'mercurial.cext.parsers',
-'mercurial/cext/dirs.c',
+[
-'mercurial/cext/manifest.c',
+'mercurial/cext/charencode.c',
-'mercurial/cext/parsers.c',
+'mercurial/cext/dirs.c',
-'mercurial/cext/pathencode.c',
+'mercurial/cext/manifest.c',
-'mercurial/cext/revlog.c'],
+'mercurial/cext/parsers.c',
+'mercurial/cext/pathencode.c',
+'mercurial/cext/revlog.c',
+],
 'hgdirectffi',
 'hg-direct-ffi',
 include_dirs=common_include_dirs,
-depends=common_depends + ['mercurial/cext/charencode.h',
+depends=common_depends
-'mercurial/cext/revlog.h',
++ [
-'rust/hg-core/src/ancestors.rs',
+'mercurial/cext/charencode.h',
-'rust/hg-core/src/lib.rs']),
+'mercurial/cext/revlog.h',
-Extension('mercurial.cext.osutil', ['mercurial/cext/osutil.c'],
+'rust/hg-core/src/ancestors.rs',
-include_dirs=common_include_dirs,
+'rust/hg-core/src/lib.rs',
-extra_compile_args=osutil_cflags,
+],
-extra_link_args=osutil_ldflags,
+),
-depends=common_depends),
 Extension(
-'mercurial.thirdparty.zope.interface._zope_interface_coptimizations', [
+'mercurial.cext.osutil',
-'mercurial/thirdparty/zope/interface/_zope_interface_coptimizations.c',
+['mercurial/cext/osutil.c'],
-]),
+include_dirs=common_include_dirs,
-Extension('hgext.fsmonitor.pywatchman.bser',
+extra_compile_args=osutil_cflags,
-['hgext/fsmonitor/pywatchman/bser.c']),
+extra_link_args=osutil_ldflags,
-RustStandaloneExtension('mercurial.rustext', 'hg-cpython', 'librusthg',
+depends=common_depends,
-py3_features='python3'),
+),
-]
+Extension(
+'mercurial.thirdparty.zope.interface._zope_interface_coptimizations',
+[
+'mercurial/thirdparty/zope/interface/_zope_interface_coptimizations.c',
+],
+),
+Extension(
+'hgext.fsmonitor.pywatchman.bser', ['hgext/fsmonitor/pywatchman/bser.c']
+),
+RustStandaloneExtension(
+'mercurial.rustext', 'hg-cpython', 'librusthg', py3_features='python3'
+),
+]
 sys.path.insert(0, 'contrib/python-zstandard')
 import setup_zstd
-extmodules.append(setup_zstd.get_c_extension(
-name='mercurial.zstd',
+extmodules.append(
-root=os.path.abspath(os.path.dirname(__file__))))
+setup_zstd.get_c_extension(
+name='mercurial.zstd', root=os.path.abspath(os.path.dirname(__file__))
+)
+)
 try:
 from distutils import cygwinccompiler
 # the -mno-cygwin option has been deprecated for years
 # distributions like the ones from the optware project for Synology
 # DiskStation boxes
 class HackedMingw32CCompiler(object):
 pass
 if os.name == 'nt':
 # Allow compiler/linker flags to be added to Visual Studio builds.  Passing
 # extra_link_args to distutils.extensions.Extension() doesn't have any
 # effect.
 from distutils import msvccompiler
 self.ldflags_shared.append('/ignore:4197')
 self.ldflags_shared_debug.append('/ignore:4197')
 msvccompiler.MSVCCompiler = HackedMSVCCompiler
-packagedata = {'mercurial': ['locale/*/LC_MESSAGES/hg.mo',
+packagedata = {
-'help/*.txt',
+'mercurial': [
-'help/internals/*.txt',
+'locale/*/LC_MESSAGES/hg.mo',
-'default.d/*.rc',
+'help/*.txt',
-'dummycert.pem']}
+'help/internals/*.txt',
+'default.d/*.rc',
+'dummycert.pem',
+]
+}
 def ordinarypath(p):
 return p and p[0] != '.' and p[-1] != '~'
 for root in ('templates',):
 for curdir, dirs, files in os.walk(os.path.join('mercurial', root)):
 curdir = curdir.split(os.sep, 1)[1]
 dirs[:] = filter(ordinarypath, dirs)
 if issetuptools:
 extra['python_requires'] = supportedpy
 if py2exeloaded:
 extra['console'] = [
-{'script':'hg',
+{
-'copyright':'Copyright (C) 2005-2019 Matt Mackall and others',
+'script': 'hg',
-'product_version':version}]
+'copyright': 'Copyright (C) 2005-2019 Matt Mackall and others',
+'product_version': version,
+}
+]
 # Sub command of 'build' because 'py2exe' does not handle sub_commands.
 # Need to override hgbuild because it has a private copy of
 # build.sub_commands.
 hgbuild.sub_commands.insert(0, ('build_hgextindex', None))
 # put dlls in sub directory so that they won't pollute PATH
 version = runcmd(['/usr/bin/xcodebuild', '-version'], {})[1].splitlines()
 if version:
 version = version[0]
 if sys.version_info[0] == 3:
 version = version.decode('utf-8')
-xcode4 = (version.startswith('Xcode') and
+xcode4 = version.startswith('Xcode') and StrictVersion(
-StrictVersion(version.split()[1]) >= StrictVersion('4.0'))
+version.split()[1]
+) >= StrictVersion('4.0')
 xcode51 = re.match(r'^Xcode\s+5\.1', version) is not None
 else:
 # xcodebuild returns empty on OS X Lion with XCode 4.3 not
 # installed, but instead with only command-line tools. Assume
 # that only happens on >= Lion, thus no PPC support.
 # so Mercurial can continue to compile in the meantime.
 if xcode51:
 cflags = get_config_var('CFLAGS')
 if cflags and re.search(r'-mno-fused-madd\b', cflags) is not None:
 os.environ['CFLAGS'] = (
-os.environ.get('CFLAGS', '') + ' -Qunused-arguments')
+os.environ.get('CFLAGS', '') + ' -Qunused-arguments'
+)
-setup(name='mercurial',
-version=setupversion,
+setup(
-author='Matt Mackall and many others',
+name='mercurial',
-author_email='mercurial@mercurial-scm.org',
+version=setupversion,
-url='https://mercurial-scm.org/',
+author='Matt Mackall and many others',
-download_url='https://mercurial-scm.org/release/',
+author_email='mercurial@mercurial-scm.org',
-description=('Fast scalable distributed SCM (revision control, version '
+url='https://mercurial-scm.org/',
-'control) system'),
+download_url='https://mercurial-scm.org/release/',
-long_description=('Mercurial is a distributed SCM tool written in Python.'
+description=(
-' It is used by a number of large projects that require'
+'Fast scalable distributed SCM (revision control, version '
-' fast, reliable distributed revision control, such as '
+'control) system'
-'Mozilla.'),
+),
-license='GNU GPLv2 or any later version',
+long_description=(
-classifiers=[
+'Mercurial is a distributed SCM tool written in Python.'
-'Development Status :: 6 - Mature',
+' It is used by a number of large projects that require'
-'Environment :: Console',
+' fast, reliable distributed revision control, such as '
-'Intended Audience :: Developers',
+'Mozilla.'
-'Intended Audience :: System Administrators',
+),
-'License :: OSI Approved :: GNU General Public License (GPL)',
+license='GNU GPLv2 or any later version',
-'Natural Language :: Danish',
+classifiers=[
-'Natural Language :: English',
+'Development Status :: 6 - Mature',
-'Natural Language :: German',
+'Environment :: Console',
-'Natural Language :: Italian',
+'Intended Audience :: Developers',
-'Natural Language :: Japanese',
+'Intended Audience :: System Administrators',
-'Natural Language :: Portuguese (Brazilian)',
+'License :: OSI Approved :: GNU General Public License (GPL)',
-'Operating System :: Microsoft :: Windows',
+'Natural Language :: Danish',
-'Operating System :: OS Independent',
+'Natural Language :: English',
-'Operating System :: POSIX',
+'Natural Language :: German',
-'Programming Language :: C',
+'Natural Language :: Italian',
-'Programming Language :: Python',
+'Natural Language :: Japanese',
-'Topic :: Software Development :: Version Control',
+'Natural Language :: Portuguese (Brazilian)',
-],
+'Operating System :: Microsoft :: Windows',
-scripts=scripts,
+'Operating System :: OS Independent',
-packages=packages,
+'Operating System :: POSIX',
-ext_modules=extmodules,
+'Programming Language :: C',
-data_files=datafiles,
+'Programming Language :: Python',
-package_data=packagedata,
+'Topic :: Software Development :: Version Control',
-cmdclass=cmdclass,
+],
-distclass=hgdist,
+scripts=scripts,
-options={
+packages=packages,
-'py2exe': {
+ext_modules=extmodules,
-'bundle_files': 3,
+data_files=datafiles,
-'dll_excludes': py2exedllexcludes,
+package_data=packagedata,
-'excludes': py2exeexcludes,
+cmdclass=cmdclass,
-'packages': py2exepackages,
+distclass=hgdist,
-},
+options={
-'bdist_mpkg': {
+'py2exe': {
-'zipdist': False,
+'bundle_files': 3,
-'license': 'COPYING',
+'dll_excludes': py2exedllexcludes,
-'readme': 'contrib/packaging/macosx/Readme.html',
+'excludes': py2exeexcludes,
-'welcome': 'contrib/packaging/macosx/Welcome.html',
+'packages': py2exepackages,
 },
-},
+'bdist_mpkg': {
-**extra)
+'zipdist': False,
+'license': 'COPYING',
+'readme': 'contrib/packaging/macosx/Readme.html',
+'welcome': 'contrib/packaging/macosx/Welcome.html',
+},
+},
+**extra
+)

changeset 43076	2372284d9457
parent 43044	f9d35f01b8b3
child 43349	c3e10f705a6c