#

# This is the mercurial setup script.

#

# 'python setup.py install', or

# 'python setup.py --help' for more options

import os

supportedpy = '~= 2.7'

if os.environ.get('HGALLOWPYTHON3', ''):

    # Mercurial will never work on Python 3 before 3.5 due to a lack

    # of % formatting on bytestrings, and can't work on 3.6.0 or 3.6.1

    # due to a bug in % formatting in bytestrings.

    # We cannot support Python 3.5.0, 3.5.1, 3.5.2 because of bug in

    # 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([

        '>=2.7',

        '!=3.0.*',

        '!=3.1.*',

        '!=3.2.*',

        '!=3.3.*',

        '!=3.4.*',

        '!=3.5.0',

        '!=3.5.1',

        '!=3.5.2',

        '!=3.6.0',

        '!=3.6.1',

    ])

import sys, platform

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. '

                   '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) :

            pip_message = (

                'Your pip version is out of date, please install '

                '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)

    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

# backdoor to enable working on Python 3.

if sys.version_info[0] != 2:

    badpython = True

    # Allow Python 3 from source checkouts.

    if os.path.isdir('.hg') or 'HGPYTHON3' in os.environ:

        badpython = False

    if badpython:

        error = """

Python {py} detected.

Mercurial currently has beta support for Python 3 and use of Python 2.7 is

recommended for the best experience.

Please re-run with Python 2.7 for a faster, less buggy experience.

If you would like to beta test Mercurial with Python 3, this error can

be suppressed by defining the HGPYTHON3 environment variable when invoking

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]))

        printf(error, file=sys.stderr)

        sys.exit(1)

# Solaris Python packaging brain damage

try:

    import hashlib

    sha = hashlib.sha1()

except ImportError:

    try:

        import sha

        sha.sha # silence unused import warning

    except ImportError:

        raise SystemExit(

            "Couldn't import standard hashlib (incomplete Python install).")

try:

    import zlib

    zlib.compressobj # silence unused import warning

except ImportError:

    raise SystemExit(

        "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()

                    .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

    except ImportError:

        raise SystemExit(

            "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

# (see mercurial/__modulepolicy__.py)

if hgrustext != 'cpython' and hgrustext is not None:

    hgrustext = 'direct-ffi'

import ctypes

import errno

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)

if issetuptools:

    from setuptools import setup

else:

    from distutils.core import setup

from distutils.ccompiler import new_compiler

from distutils.core import Command, Extension

from distutils.dist import Distribution

from distutils.command.build import build

from distutils.command.build_ext import build_ext

from distutils.command.build_py import build_py

from distutils.command.build_scripts import build_scripts

from distutils.command.install import install

from distutils.command.install_lib import install_lib

from distutils.command.install_scripts import install_scripts

from distutils.spawn import spawn, find_executable

from distutils import file_util

from distutils.errors import (

    CCompilerError,

    DistutilsError,

    DistutilsExecError,

)

from distutils.sysconfig import get_python_inc, get_config_var

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()

    else:

        current = b''

    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:

        fname = os.path.join(tmpdir, 'testcomp.c')

        f = open(fname, 'w')

        f.write(code)

        f.close()

        # Redirect stderr to /dev/null to hide any error messages

        # from the compiler.

        # This will have to be changed if we ever have to check

        # for a function on Windows.

        devnull = open('/dev/null', 'w')

        oldstderr = os.dup(sys.stderr.fileno())

        os.dup2(devnull.fileno(), sys.stderr.fileno())

        objects = cc.compile([fname], output_dir=tmpdir)

        cc.link_executable(objects, os.path.join(tmpdir, "a.out"))

        return True

    except Exception:

        return False

    finally:

        if oldstderr is not None:

            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

    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,

                         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

    def run(self, args):

        cmd = self.cmd + args

        returncode, out, err = runcmd(cmd, self.env)

        err = filterhgerr(err)

        if err or returncode != 0:

            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()

           if (not e.startswith(b'not trusting file')

               and not e.startswith(b'warning: Not importing')

               and not e.startswith(b'obsolete feature not enabled')

               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.

    Returns an hgcommand object."""

    # By default, prefer the "hg" command in the user's path.  This was

    # presumably the hg command that the user used to create this repository.

    #

    # This repository may require extensions or other settings that would not

    # be enabled by running the hg script directly from this local repository.

    hgenv = os.environ.copy()

    # Use HGPLAIN to disable hgrc settings that would change output formatting,

    # and disable localization for the same reasons.

    hgenv['HGPLAIN'] = '1'

    hgenv['LANGUAGE'] = 'C'

    hgcmd = ['hg']

    # Run a simple "hg log" command just to see if using hg from the user's

    # path works and can successfully interact with this repository.  Windows

    # gives precedence to hg.exe in the current directory, so fall back to the

    # python invocation of local hg, where pythonXY.dll can always be found.

    check_cmd = ['log', '-r.', '-Ttest']

    if os.name != 'nt':

        try:

            retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)

        except EnvironmentError:

            retcode = -1

        if retcode == 0 and not filterhgerr(err):

            return hgcommand(hgcmd, hgenv)

    # Fall back to trying the local hg installation.

    hgenv = localhgenv()

    hgcmd = [sys.executable, 'hg']

    try:

        retcode, out, err = runcmd(hgcmd + check_cmd, hgenv)

    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 '

                     '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',

           'HGRCPATH': '',

           '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()

    cmd = ['log', '-r', '.', '--template', '{tags}\n']

    numerictags = [t for t in sysstr(hg.run(cmd)).split() if t[0:1].isdigit()]

    hgid = sysstr(hg.run(['id', '-i'])).strip()

    if not hgid:

        # 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

        version = numerictags[-1]

        if hgid.endswith('+'): # propagate the dirty status to the tag

            version += '+'

    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)]

               for l in open('.hg_archival.txt')])

    if 'tag' in kw:

        version = kw['tag']

    elif 'latesttag' in kw: