.-.-.-.-.-

config.pyc000064400000006755151702014350006541 0ustar00�
{fc@sRdZddlZddlmZddlmZdZdefd��YZdS(s�distutils.pypirc

Provides the PyPIRCCommand class, the base class for the command classes
that uses .pypirc in the distutils.command package.
i����N(tConfigParser(tCommandsE[distutils]
index-servers =
    pypi

[pypi]
username:%s
password:%s
t
PyPIRCCommandcBsueZdZdZdZd
Zd
ZdddefdgZdgZ	d�Z
d	�Zd
�Zd�Z
d�ZRS(s;Base command that knows how to handle the .pypirc file
    shttps://upload.pypi.org/legacy/tpypisrepository=trsurl of repository [default: %s]s
show-responses&display full response text from servercCstjjtjjd�d�S(sReturns rc file path.t~s.pypirc(tostpathtjoint
expanduser(tself((s(/usr/lib64/python2.7/distutils/config.pyt_get_rc_file&scCsd|j�}tjtj|tjtjBd�d�}z|jt||f�Wd|j�XdS(sCreates a default .pypirc file.i�twN(	RRtfdopentopentO_CREATtO_WRONLYtwritetDEFAULT_PYPIRCtclose(R
tusernametpasswordtrctf((s(/usr/lib64/python2.7/distutils/config.pyt
_store_pypirc*s
+cCs3|j�}tjj|�r/|jd|�|jp>|j}t�}|j|�|j	�}d|kr�|j
dd�}g|jd�D]$}|j�dkr�|j�^q�}|gkr�d|kr�dg}q�iSnxC|D]�}i|d6}|j
|d�|d<xdd	|jfd
|j
fdfD]A\}	}
|j||	�ro|j
||	�||	<q8|
||	<q8W|d|ks�|d	|kr�|Sq�Wq/d|kr/d}|j|d	�r�|j
|d	�}n	|j}i|j
|d�d6|j
|d�d6|d	6|d6|j
d
6SniS(sReads the .pypirc file.sUsing PyPI login from %st	distutilss
index-serverss
tRtserverRt
repositorytrealmRsserver-loginN(RN(RRRtexiststannounceRtDEFAULT_REPOSITORYRtreadtsectionstgettsplittstript
DEFAULT_REALMtNonet
has_option(R
RRtconfigR"t
index_serversRt_serverstcurrenttkeytdefault((s(/usr/lib64/python2.7/distutils/config.pyt_read_pypirc3sP	
$

cCsd|_d|_d|_dS(sInitialize options.iN(R'RRt
show_response(R
((s(/usr/lib64/python2.7/distutils/config.pytinitialize_optionsis		cCs@|jdkr|j|_n|jdkr<|j|_ndS(sFinalizes options.N(RR'R RR&(R
((s(/usr/lib64/python2.7/distutils/config.pytfinalize_optionsosN(s
show-responseNs&display full response text from server(t__name__t
__module__t__doc__R R&R'RRtuser_optionstboolean_optionsRRR/R1R2(((s(/usr/lib64/python2.7/distutils/config.pyRs 						6	(R5RRt
distutils.cmdRRR(((s(/usr/lib64/python2.7/distutils/config.pyt<module>s

command/bdist_wininst.py000064400000035227151702014350011423 0ustar00"""distutils.command.bdist_wininst

Implements the Distutils 'bdist_wininst' command: create a windows installer
exe-program."""

__revision__ = "$Id$"

import sys
import os
import string

from sysconfig import get_python_version

from distutils.core import Command
from distutils.dir_util import remove_tree
from distutils.errors import DistutilsOptionError, DistutilsPlatformError
from distutils import log
from distutils.util import get_platform

class bdist_wininst (Command):

description = "create an executable installer for MS Windows"

user_options = [('bdist-dir=', None,
                     "temporary directory for creating the distribution"),
                    ('plat-name=', 'p',
                     "platform name to embed in generated filenames "
                     "(default: %s)" % get_platform()),
                    ('keep-temp', 'k',
                     "keep the pseudo-installation tree around after " +
                     "creating the distribution archive"),
                    ('target-version=', None,
                     "require a specific python version" +
                     " on the target system"),
                    ('no-target-compile', 'c',
                     "do not compile .py to .pyc on the target system"),
                    ('no-target-optimize', 'o',
                     "do not compile .py to .pyo (optimized) "
                     "on the target system"),
                    ('dist-dir=', 'd',
                     "directory to put final built distributions in"),
                    ('bitmap=', 'b',
                     "bitmap to use for the installer instead of python-powered logo"),
                    ('title=', 't',
                     "title to display on the installer background instead of default"),
                    ('skip-build', None,
                     "skip rebuilding everything (for testing/debugging)"),
                    ('install-script=', None,
                     "basename of installation script to be run after "
                     "installation or before deinstallation"),
                    ('pre-install-script=', None,
                     "Fully qualified filename of a script to be run before "
                     "any files are installed.  This script need not be in the "
                     "distribution"),
                    ('user-access-control=', None,
                     "specify Vista's UAC handling - 'none'/default=no "
                     "handling, 'auto'=use UAC if target Python installed for "
                     "all users, 'force'=always use UAC"),
                   ]

boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
                       'skip-build']

def initialize_options (self):
        self.bdist_dir = None
        self.plat_name = None
        self.keep_temp = 0
        self.no_target_compile = 0
        self.no_target_optimize = 0
        self.target_version = None
        self.dist_dir = None
        self.bitmap = None
        self.title = None
        self.skip_build = None
        self.install_script = None
        self.pre_install_script = None
        self.user_access_control = None

# initialize_options()

def finalize_options (self):
        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))

if self.bdist_dir is None:
            if self.skip_build and self.plat_name:
                # If build is skipped and plat_name is overridden, bdist will
                # not see the correct 'plat_name' - so set that up manually.
                bdist = self.distribution.get_command_obj('bdist')
                bdist.plat_name = self.plat_name
                # next the command will be initialized using that name
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'wininst')

if not self.target_version:
            self.target_version = ""

if not self.skip_build and self.distribution.has_ext_modules():
            short_version = get_python_version()
            if self.target_version and self.target_version != short_version:
                raise DistutilsOptionError, \
                      "target version can only be %s, or the '--skip-build'" \
                      " option must be specified" % (short_version,)
            self.target_version = short_version

self.set_undefined_options('bdist',
                                   ('dist_dir', 'dist_dir'),
                                   ('plat_name', 'plat_name'),
                                  )

if self.install_script:
            for script in self.distribution.scripts:
                if self.install_script == os.path.basename(script):
                    break
            else:
                raise DistutilsOptionError, \
                      "install_script '%s' not found in scripts" % \
                      self.install_script
    # finalize_options()

def run (self):
        if (sys.platform != "win32" and
            (self.distribution.has_ext_modules() or
             self.distribution.has_c_libraries())):
            raise DistutilsPlatformError \
                  ("distribution contains extensions and/or C libraries; "
                   "must be compiled on a Windows 32 platform")

if not self.skip_build:
            self.run_command('build')

install = self.reinitialize_command('install', reinit_subcommands=1)
        install.root = self.bdist_dir
        install.skip_build = self.skip_build
        install.warn_dir = 0
        install.plat_name = self.plat_name

install_lib = self.reinitialize_command('install_lib')
        # we do not want to include pyc or pyo files
        install_lib.compile = 0
        install_lib.optimize = 0

if self.distribution.has_ext_modules():
            # If we are building an installer for a Python version other
            # than the one we are currently running, then we need to ensure
            # our build_lib reflects the other Python version rather than ours.
            # Note that for target_version!=sys.version, we must have skipped the
            # build step, so there is no issue with enforcing the build of this
            # version.
            target_version = self.target_version
            if not target_version:
                assert self.skip_build, "Should have already checked this"
                target_version = sys.version[0:3]
            plat_specifier = ".%s-%s" % (self.plat_name, target_version)
            build = self.get_finalized_command('build')
            build.build_lib = os.path.join(build.build_base,
                                           'lib' + plat_specifier)

# Use a custom scheme for the zip-file, because we have to decide
        # at installation time which scheme to use.
        for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'):
            value = string.upper(key)
            if key == 'headers':
                value = value + '/Include/$dist_name'
            setattr(install,
                    'install_' + key,
                    value)

log.info("installing to %s", self.bdist_dir)
        install.ensure_finalized()

# avoid warning of 'install_lib' about installing
        # into a directory not in sys.path
        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))

install.run()

del sys.path[0]

# And make an archive relative to the root of the
        # pseudo-installation tree.
        from tempfile import mktemp
        archive_basename = mktemp()
        fullname = self.distribution.get_fullname()
        arcname = self.make_archive(archive_basename, "zip",
                                    root_dir=self.bdist_dir)
        # create an exe containing the zip-file
        self.create_exe(arcname, fullname, self.bitmap)
        if self.distribution.has_ext_modules():
            pyversion = get_python_version()
        else:
            pyversion = 'any'
        self.distribution.dist_files.append(('bdist_wininst', pyversion,
                                             self.get_installer_filename(fullname)))
        # remove the zip-file again
        log.debug("removing temporary file '%s'", arcname)
        os.remove(arcname)

if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)

# run()

def get_inidata (self):
        # Return data describing the installation.

lines = []
        metadata = self.distribution.metadata

# Write the [metadata] section.
        lines.append("[metadata]")

# 'info' will be displayed in the installer's dialog box,
        # describing the items to be installed.
        info = (metadata.long_description or '') + '\n'

# Escape newline characters
        def escape(s):
            return string.replace(s, "\n", "\\n")

for name in ["author", "author_email", "description", "maintainer",
                     "maintainer_email", "name", "url", "version"]:
            data = getattr(metadata, name, "")
            if data:
                info = info + ("\n    %s: %s" % \
                               (string.capitalize(name), escape(data)))
                lines.append("%s=%s" % (name, escape(data)))

# The [setup] section contains entries controlling
        # the installer runtime.
        lines.append("\n[Setup]")
        if self.install_script:
            lines.append("install_script=%s" % self.install_script)
        lines.append("info=%s" % escape(info))
        lines.append("target_compile=%d" % (not self.no_target_compile))
        lines.append("target_optimize=%d" % (not self.no_target_optimize))
        if self.target_version:
            lines.append("target_version=%s" % self.target_version)
        if self.user_access_control:
            lines.append("user_access_control=%s" % self.user_access_control)

title = self.title or self.distribution.get_fullname()
        lines.append("title=%s" % escape(title))
        import time
        import distutils
        build_info = "Built %s with distutils-%s" % \
                     (time.ctime(time.time()), distutils.__version__)
        lines.append("build_info=%s" % build_info)
        return string.join(lines, "\n")

# get_inidata()

def create_exe (self, arcname, fullname, bitmap=None):
        import struct

self.mkpath(self.dist_dir)

cfgdata = self.get_inidata()

installer_name = self.get_installer_filename(fullname)
        self.announce("creating %s" % installer_name)

if bitmap:
            bitmapdata = open(bitmap, "rb").read()
            bitmaplen = len(bitmapdata)
        else:
            bitmaplen = 0

file = open(installer_name, "wb")
        file.write(self.get_exe_bytes())
        if bitmap:
            file.write(bitmapdata)

# Convert cfgdata from unicode to ascii, mbcs encoded
        try:
            unicode
        except NameError:
            pass
        else:
            if isinstance(cfgdata, unicode):
                cfgdata = cfgdata.encode("mbcs")

# Append the pre-install script
        cfgdata = cfgdata + "\0"
        if self.pre_install_script:
            script_data = open(self.pre_install_script, "r").read()
            cfgdata = cfgdata + script_data + "\n\0"
        else:
            # empty pre-install script
            cfgdata = cfgdata + "\0"
        file.write(cfgdata)

# The 'magic number' 0x1234567B is used to make sure that the
        # binary layout of 'cfgdata' is what the wininst.exe binary
        # expects.  If the layout changes, increment that number, make
        # the corresponding changes to the wininst.exe sources, and
        # recompile them.
        header = struct.pack("<iii",
                             0x1234567B,       # tag
                             len(cfgdata),     # length
                             bitmaplen,        # number of bytes in bitmap
                             )
        file.write(header)
        file.write(open(arcname, "rb").read())

# create_exe()

def get_installer_filename(self, fullname):
        # Factored out to allow overriding in subclasses
        if self.target_version:
            # if we create an installer for a specific python version,
            # it's better to include this in the name
            installer_name = os.path.join(self.dist_dir,
                                          "%s.%s-py%s.exe" %
                                           (fullname, self.plat_name, self.target_version))
        else:
            installer_name = os.path.join(self.dist_dir,
                                          "%s.%s.exe" % (fullname, self.plat_name))
        return installer_name
    # get_installer_filename()

def get_exe_bytes (self):
        from distutils.msvccompiler import get_build_version
        # If a target-version other than the current version has been
        # specified, then using the MSVC version from *this* build is no good.
        # Without actually finding and executing the target version and parsing
        # its sys.version, we just hard-code our knowledge of old versions.
        # NOTE: Possible alternative is to allow "--target-version" to
        # specify a Python executable rather than a simple version string.
        # We can then execute this program to obtain any info we need, such
        # as the real sys.version string for the build.
        cur_version = get_python_version()
        if self.target_version and self.target_version != cur_version:
            # If the target version is *later* than us, then we assume they
            # use what we use
            # string compares seem wrong, but are what sysconfig.py itself uses
            if self.target_version > cur_version:
                bv = get_build_version()
            else:
                if self.target_version < "2.4":
                    bv = 6.0
                else:
                    bv = 7.1
        else:
            # for current version - use authoritative check.
            bv = get_build_version()

# wininst-x.y.exe is in the same directory as this file
        directory = os.path.dirname(__file__)
        # we must use a wininst-x.y.exe built with the same C compiler
        # used for python.  XXX What about mingw, borland, and so on?

# if plat_name starts with "win" but is not "win32"
        # we want to strip "win" and leave the rest (e.g. -amd64)
        # for all other cases, we don't want any suffix
        if self.plat_name != 'win32' and self.plat_name[:3] == 'win':
            sfix = self.plat_name[3:]
        else:
            sfix = ''

filename = os.path.join(directory, "wininst-%.1f%s.exe" % (bv, sfix))
        f = open(filename, "rb")
        try:
            return f.read()
        finally:
            f.close()
# class bdist_wininst
command/bdist_wininst.pyc000064400000024745151702014350011571 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZddlmZddl	m
Z
ddlmZm
Z
ddlmZdd	lmZd
efd��YZdS(szdistutils.command.bdist_wininst

Implements the Distutils 'bdist_wininst' command: create a windows installer
exe-program.s$Id$i����N(tget_python_version(tCommand(tremove_tree(tDistutilsOptionErrortDistutilsPlatformError(tlog(tget_platformt
bdist_wininstcBs�eZdZd,ddde�fdddd	fd
d+ddfd-d.d/d0d1d2d3d4d5g
Zdd
ddgZd$�Zd%�Zd&�Z	d'�Z
d+d(�Zd)�Zd*�Z
RS(6s-create an executable installer for MS Windowss
bdist-dir=s1temporary directory for creating the distributions
plat-name=tps;platform name to embed in generated filenames (default: %s)s	keep-temptks/keep the pseudo-installation tree around after s!creating the distribution archivestarget-version=s!require a specific python versions on the target systemsno-target-compiletcs/do not compile .py to .pyc on the target systemsno-target-optimizetos;do not compile .py to .pyo (optimized) on the target systems	dist-dir=tds-directory to put final built distributions insbitmap=tbs>bitmap to use for the installer instead of python-powered logostitle=tts?title to display on the installer background instead of defaults
skip-builds2skip rebuilding everything (for testing/debugging)sinstall-script=sUbasename of installation script to be run after installation or before deinstallationspre-install-script=s{Fully qualified filename of a script to be run before any files are installed.  This script need not be in the distributionsuser-access-control=s�specify Vista's UAC handling - 'none'/default=no handling, 'auto'=use UAC if target Python installed for all users, 'force'=always use UACcCsyd|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_d|_d|_
dS(Ni(tNonet	bdist_dirt	plat_namet	keep_temptno_target_compiletno_target_optimizettarget_versiontdist_dirtbitmapttitlet
skip_buildtinstall_scripttpre_install_scripttuser_access_control(tself((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pytinitialize_options@s												cCsV|jdd	�|jdkr|jrR|jrR|jjd�}|j|_n|jd�j}t	j
j|d�|_n|js�d|_n|jr�|jj
�r�t�}|jr�|j|kr�td|f�n||_n|jdd
d�|jrRxF|jjD]%}|jt	j
j|�krPqqWtd|j�ndS(NtbdistRtwininsttsMtarget version can only be %s, or the '--skip-build' option must be specifiedRRs(install_script '%s' not found in scripts(RR(RR(RR(tset_undefined_optionsRRRRtdistributiontget_command_objtget_finalized_commandt
bdist_basetostpathtjoinRthas_ext_modulesRRRtscriptstbasename(RRR&t
short_versiontscript((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pytfinalize_optionsRs4		
		c
Cs�tjdkr<|jj�s-|jj�r<td��n|jsU|jd�n|jddd�}|j	|_
|j|_d|_|j|_|jd�}d|_
d|_|jj�rB|j}|s�|js�td	��tjdd
!}nd|j|f}|jd�}tjj|jd|�|_nxJdD]B}tj|�}|dkrw|d}nt|d||�qIWtjd|j	�|j�tjjdtjj|j	d��|j�tjd=ddl m!}|�}	|jj"�}
|j#|	dd|j	�}|j$||
|j%�|jj�rYt&�}nd}|jj'j(d||j)|
�f�tj*d|�tj+|�|j,s�t-|j	d|j.�ndS(Ntwin32s^distribution contains extensions and/or C libraries; must be compiled on a Windows 32 platformtbuildtinstalltreinit_subcommandsiitinstall_libs Should have already checked thisis.%s-%stlibtpurelibtplatlibtheadersR+tdatas/Include/$dist_nametinstall_sinstalling to %stPURELIBi����(tmktemptziptroot_dirtanyRsremoving temporary file '%s'tdry_run(R6R7R8R+R9(/tsystplatformR#R*thas_c_librariesRRtrun_commandtreinitialize_commandRtroottwarn_dirRtcompiletoptimizeRtAssertionErrortversionR%R'R(R)t
build_baset	build_libtstringtuppertsetattrRtinfotensure_finalizedtinserttrunttempfileR<tget_fullnametmake_archivet
create_exeRRt
dist_filestappendtget_installer_filenametdebugtremoveRRR@(
RR2R4Rtplat_specifierR1tkeytvalueR<tarchive_basenametfullnametarcnamet	pyversion((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyRTzsf

cCs�g}|jj}|jd�|jp+dd}d�}x�ddddd	d
ddgD]a}t||d�}|rZ|d
tj|�||�f}|jd|||�f�qZqZW|jd�|jr�|jd|j�n|jd||��|jd|j�|jd|j	�|j
rM|jd|j
�n|jrm|jd|j�n|jp�|jj
�}|jd||��ddl}ddl}	d|j|j��|	jf}
|jd|
�tj|d�S(Ns
[metadata]R!s
cSstj|dd�S(Ns
s\n(RNtreplace(ts((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pytescape�stauthortauthor_emailtdescriptiont
maintainertmaintainer_emailtnameturlRKs
    %s: %ss%s=%ss
[Setup]sinstall_script=%ssinfo=%sstarget_compile=%dstarget_optimize=%dstarget_version=%ssuser_access_control=%sstitle=%si����sBuilt %s with distutils-%ss
build_info=%s(R#tmetadataRZtlong_descriptiontgetattrRNt
capitalizeRRRRRRRVttimet	distutilstctimet__version__R)(RtlinesRoRQRgRmR9RRsRtt
build_info((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pytget_inidata�s<
	$
			cCs�ddl}|j|j�|j�}|j|�}|jd|�|rrt|d�j�}t|�}nd}t|d�}	|	j	|j
��|r�|	j	|�nytWntk
r�n"Xt
|t�r�|jd�}n|d}|jr)t|jd�j�}
||
d	}n
|d}|	j	|�|jd
dt|�|�}|	j	|�|	j	t|d�j��dS(Ni����screating %strbitwbtmbcsstrs
s<iiii{V4(tstructtmkpathRRyR[tannouncetopentreadtlentwritet
get_exe_bytestunicodet	NameErrort
isinstancetencodeRtpack(RRcRbRR~tcfgdatatinstaller_namet
bitmapdatat	bitmaplentfiletscript_datatheader((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyRX�s>

cCs`|jr7tjj|jd||j|jf�}n%tjj|jd||jf�}|S(Ns%s.%s-py%s.exes	%s.%s.exe(RR'R(R)RR(RRbR�((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyR[5s	cCsddlm}t�}|jrm|j|krm|j|krL|�}qv|jdkrdd}qvd}n	|�}tjjt�}|jdkr�|jd dkr�|jd}nd	}tjj	|d
||f�}t
|d�}z|j�SWd|j�XdS(Ni����(tget_build_versions2.4g@gffffff@R0itwinR!swininst-%.1f%s.exeRz(
tdistutils.msvccompilerR�RRR'R(tdirnamet__file__RR)R�R�tclose(RR�tcur_versiontbvt	directorytsfixtfilenametf((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyR�Cs$					"N(s
bdist-dir=Ns1temporary directory for creating the distribution(sno-target-compileR
s/do not compile .py to .pyc on the target system(sno-target-optimizeRs;do not compile .py to .pyo (optimized) on the target system(s	dist-dir=Rs-directory to put final built distributions in(sbitmap=R
s>bitmap to use for the installer instead of python-powered logo(stitle=Rs?title to display on the installer background instead of default(s
skip-buildNs2skip rebuilding everything (for testing/debugging)(sinstall-script=NsUbasename of installation script to be run after installation or before deinstallation(spre-install-script=Ns{Fully qualified filename of a script to be run before any files are installed.  This script need not be in the distribution(suser-access-control=Ns�specify Vista's UAC handling - 'none'/default=no handling, 'auto'=use UAC if target Python installed for all users, 'force'=always use UAC(t__name__t
__module__RjRRtuser_optionstboolean_optionsRR/RTRyRXR[R�(((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyRsN
					(	S	17	(t__doc__t__revision__RAR'RNt	sysconfigRtdistutils.coreRtdistutils.dir_utilRtdistutils.errorsRRRtRtdistutils.utilRR(((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyt<module>scommand/bdist_wininst.pyo000064400000024626151702014350011603 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZddlmZddl	m
Z
ddlmZm
Z
ddlmZdd	lmZd
efd��YZdS(szdistutils.command.bdist_wininst

Implements the Distutils 'bdist_wininst' command: create a windows installer
exe-program.s$Id$i����N(tget_python_version(tCommand(tremove_tree(tDistutilsOptionErrortDistutilsPlatformError(tlog(tget_platformt
bdist_wininstcBs�eZdZd,ddde�fdddd	fd
d+ddfd-d.d/d0d1d2d3d4d5g
Zdd
ddgZd$�Zd%�Zd&�Z	d'�Z
d+d(�Zd)�Zd*�Z
RS(6s-create an executable installer for MS Windowss
bdist-dir=s1temporary directory for creating the distributions
plat-name=tps;platform name to embed in generated filenames (default: %s)s	keep-temptks/keep the pseudo-installation tree around after s!creating the distribution archivestarget-version=s!require a specific python versions on the target systemsno-target-compiletcs/do not compile .py to .pyc on the target systemsno-target-optimizetos;do not compile .py to .pyo (optimized) on the target systems	dist-dir=tds-directory to put final built distributions insbitmap=tbs>bitmap to use for the installer instead of python-powered logostitle=tts?title to display on the installer background instead of defaults
skip-builds2skip rebuilding everything (for testing/debugging)sinstall-script=sUbasename of installation script to be run after installation or before deinstallationspre-install-script=s{Fully qualified filename of a script to be run before any files are installed.  This script need not be in the distributionsuser-access-control=s�specify Vista's UAC handling - 'none'/default=no handling, 'auto'=use UAC if target Python installed for all users, 'force'=always use UACcCsyd|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_d|_d|_
dS(Ni(tNonet	bdist_dirt	plat_namet	keep_temptno_target_compiletno_target_optimizettarget_versiontdist_dirtbitmapttitlet
skip_buildtinstall_scripttpre_install_scripttuser_access_control(tself((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pytinitialize_options@s												cCsV|jdd	�|jdkr|jrR|jrR|jjd�}|j|_n|jd�j}t	j
j|d�|_n|js�d|_n|jr�|jj
�r�t�}|jr�|j|kr�td|f�n||_n|jdd
d�|jrRxF|jjD]%}|jt	j
j|�krPqqWtd|j�ndS(NtbdistRtwininsttsMtarget version can only be %s, or the '--skip-build' option must be specifiedRRs(install_script '%s' not found in scripts(RR(RR(RR(tset_undefined_optionsRRRRtdistributiontget_command_objtget_finalized_commandt
bdist_basetostpathtjoinRthas_ext_modulesRRRtscriptstbasename(RRR&t
short_versiontscript((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pytfinalize_optionsRs4		
		c
Cs�tjdkr<|jj�s-|jj�r<td��n|jsU|jd�n|jddd�}|j	|_
|j|_d|_|j|_|jd�}d|_
d|_|jj�r-|j}|s�tjdd	!}nd
|j|f}|jd�}tjj|jd|�|_nxJdD]B}tj|�}|dkrb|d}nt|d||�q4Wtjd|j	�|j�tjjdtjj|j	d��|j�tjd=ddlm }|�}	|jj!�}
|j"|	dd|j	�}|j#||
|j$�|jj�rDt%�}nd}|jj&j'd||j(|
�f�tj)d|�tj*|�|j+s�t,|j	d|j-�ndS(Ntwin32s^distribution contains extensions and/or C libraries; must be compiled on a Windows 32 platformtbuildtinstalltreinit_subcommandsiitinstall_libis.%s-%stlibtpurelibtplatlibtheadersR+tdatas/Include/$dist_nametinstall_sinstalling to %stPURELIBi����(tmktemptziptroot_dirtanyRsremoving temporary file '%s'tdry_run(R6R7R8R+R9(.tsystplatformR#R*thas_c_librariesRRtrun_commandtreinitialize_commandRtroottwarn_dirRtcompiletoptimizeRtversionR%R'R(R)t
build_baset	build_libtstringtuppertsetattrRtinfotensure_finalizedtinserttrunttempfileR<tget_fullnametmake_archivet
create_exeRRt
dist_filestappendtget_installer_filenametdebugtremoveRRR@(
RR2R4Rtplat_specifierR1tkeytvalueR<tarchive_basenametfullnametarcnamet	pyversion((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyRSzsd

cCs�g}|jj}|jd�|jp+dd}d�}x�ddddd	d
ddgD]a}t||d�}|rZ|d
tj|�||�f}|jd|||�f�qZqZW|jd�|jr�|jd|j�n|jd||��|jd|j�|jd|j	�|j
rM|jd|j
�n|jrm|jd|j�n|jp�|jj
�}|jd||��ddl}ddl}	d|j|j��|	jf}
|jd|
�tj|d�S(Ns
[metadata]R!s
cSstj|dd�S(Ns
s\n(RMtreplace(ts((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pytescape�stauthortauthor_emailtdescriptiont
maintainertmaintainer_emailtnameturlRJs
    %s: %ss%s=%ss
[Setup]sinstall_script=%ssinfo=%sstarget_compile=%dstarget_optimize=%dstarget_version=%ssuser_access_control=%sstitle=%si����sBuilt %s with distutils-%ss
build_info=%s(R#tmetadataRYtlong_descriptiontgetattrRMt
capitalizeRRRRRRRUttimet	distutilstctimet__version__R)(RtlinesRnRPRfRlR9RRrRst
build_info((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pytget_inidata�s<
	$
			cCs�ddl}|j|j�|j�}|j|�}|jd|�|rrt|d�j�}t|�}nd}t|d�}	|	j	|j
��|r�|	j	|�nytWntk
r�n"Xt
|t�r�|jd�}n|d}|jr)t|jd�j�}
||
d	}n
|d}|	j	|�|jd
dt|�|�}|	j	|�|	j	t|d�j��dS(Ni����screating %strbitwbtmbcsstrs
s<iiii{V4(tstructtmkpathRRxRZtannouncetopentreadtlentwritet
get_exe_bytestunicodet	NameErrort
isinstancetencodeRtpack(RRbRaRR}tcfgdatatinstaller_namet
bitmapdatat	bitmaplentfiletscript_datatheader((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyRW�s>

cCs`|jr7tjj|jd||j|jf�}n%tjj|jd||jf�}|S(Ns%s.%s-py%s.exes	%s.%s.exe(RR'R(R)RR(RRaR�((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyRZ5s	cCsddlm}t�}|jrm|j|krm|j|krL|�}qv|jdkrdd}qvd}n	|�}tjjt�}|jdkr�|jd dkr�|jd}nd	}tjj	|d
||f�}t
|d�}z|j�SWd|j�XdS(Ni����(tget_build_versions2.4g@gffffff@R0itwinR!swininst-%.1f%s.exeRy(
tdistutils.msvccompilerR�RRR'R(tdirnamet__file__RR)R�R�tclose(RR�tcur_versiontbvt	directorytsfixtfilenametf((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyR�Cs$					"N(s
bdist-dir=Ns1temporary directory for creating the distribution(sno-target-compileR
s/do not compile .py to .pyc on the target system(sno-target-optimizeRs;do not compile .py to .pyo (optimized) on the target system(s	dist-dir=Rs-directory to put final built distributions in(sbitmap=R
s>bitmap to use for the installer instead of python-powered logo(stitle=Rs?title to display on the installer background instead of default(s
skip-buildNs2skip rebuilding everything (for testing/debugging)(sinstall-script=NsUbasename of installation script to be run after installation or before deinstallation(spre-install-script=Ns{Fully qualified filename of a script to be run before any files are installed.  This script need not be in the distribution(suser-access-control=Ns�specify Vista's UAC handling - 'none'/default=no handling, 'auto'=use UAC if target Python installed for all users, 'force'=always use UAC(t__name__t
__module__RiRRtuser_optionstboolean_optionsRR/RSRxRWRZR�(((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyRsN
					(	S	17	(t__doc__t__revision__RAR'RMt	sysconfigRtdistutils.coreRtdistutils.dir_utilRtdistutils.errorsRRRsRtdistutils.utilRR(((s7/usr/lib64/python2.7/distutils/command/bdist_wininst.pyt<module>scommand/build.py000064400000012520151702014350007631 0ustar00"""distutils.command.build

Implements the Distutils 'build' command."""

__revision__ = "$Id$"

import sys, os

from distutils.util import get_platform
from distutils.core import Command
from distutils.errors import DistutilsOptionError

def show_compilers():
    from distutils.ccompiler import show_compilers
    show_compilers()

class build(Command):

description = "build everything needed to install"

user_options = [
        ('build-base=', 'b',
         "base directory for build library"),
        ('build-purelib=', None,
         "build directory for platform-neutral distributions"),
        ('build-platlib=', None,
         "build directory for platform-specific distributions"),
        ('build-lib=', None,
         "build directory for all distribution (defaults to either " +
         "build-purelib or build-platlib"),
        ('build-scripts=', None,
         "build directory for scripts"),
        ('build-temp=', 't',
         "temporary build directory"),
        ('plat-name=', 'p',
         "platform name to build for, if supported "
         "(default: %s)" % get_platform()),
        ('compiler=', 'c',
         "specify the compiler type"),
        ('debug', 'g',
         "compile extensions and libraries with debugging information"),
        ('force', 'f',
         "forcibly build everything (ignore file timestamps)"),
        ('executable=', 'e',
         "specify final destination interpreter path (build.py)"),
        ]

boolean_options = ['debug', 'force']

help_options = [
        ('help-compiler', None,
         "list available compilers", show_compilers),
        ]

def initialize_options(self):
        self.build_base = 'build'
        # these are decided only after 'build_base' has its final value
        # (unless overridden by the user or client)
        self.build_purelib = None
        self.build_platlib = None
        self.build_lib = None
        self.build_temp = None
        self.build_scripts = None
        self.compiler = None
        self.plat_name = None
        self.debug = None
        self.force = 0
        self.executable = None

def finalize_options(self):
        if self.plat_name is None:
            self.plat_name = get_platform()
        else:
            # plat-name only supported for windows (other platforms are
            # supported via ./configure flags, if at all).  Avoid misleading
            # other platforms.
            if os.name != 'nt':
                raise DistutilsOptionError(
                            "--plat-name only supported on Windows (try "
                            "using './configure --help' on your platform)")

plat_specifier = ".%s-%s" % (self.plat_name, sys.version[0:3])

# Make it so Python 2.x and Python 2.x with --with-pydebug don't
        # share the same build directories. Doing so confuses the build
        # process for C modules
        if hasattr(sys, 'gettotalrefcount'):
            plat_specifier += '-pydebug'

# 'build_purelib' and 'build_platlib' just default to 'lib' and
        # 'lib.<plat>' under the base build directory.  We only use one of
        # them for a given distribution, though --
        if self.build_purelib is None:
            self.build_purelib = os.path.join(self.build_base, 'lib')
        if self.build_platlib is None:
            self.build_platlib = os.path.join(self.build_base,
                                              'lib' + plat_specifier)

# 'build_lib' is the actual directory that we will use for this
        # particular module distribution -- if user didn't supply it, pick
        # one of 'build_purelib' or 'build_platlib'.
        if self.build_lib is None:
            if self.distribution.ext_modules:
                self.build_lib = self.build_platlib
            else:
                self.build_lib = self.build_purelib

# 'build_temp' -- temporary directory for compiler turds,
        # "build/temp.<plat>"
        if self.build_temp is None:
            self.build_temp = os.path.join(self.build_base,
                                           'temp' + plat_specifier)
        if self.build_scripts is None:
            self.build_scripts = os.path.join(self.build_base,
                                              'scripts-' + sys.version[0:3])

if self.executable is None and sys.executable:
            self.executable = os.path.normpath(sys.executable)

def run(self):
        # Run all relevant sub-commands.  This will be some subset of:
        #  - build_py      - pure Python modules
        #  - build_clib    - standalone C libraries
        #  - build_ext     - Python extensions
        #  - build_scripts - (Python) scripts
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

# -- Predicates for the sub-command list ---------------------------

def has_pure_modules (self):
        return self.distribution.has_pure_modules()

def has_c_libraries (self):
        return self.distribution.has_c_libraries()

def has_ext_modules (self):
        return self.distribution.has_ext_modules()

def has_scripts (self):
        return self.distribution.has_scripts()

sub_commands = [('build_py',      has_pure_modules),
                    ('build_clib',    has_c_libraries),
                    ('build_ext',     has_ext_modules),
                    ('build_scripts', has_scripts),
                   ]
command/build.pyc000064400000012032151702014350007772 0ustar00�
{fc@swdZdZddlZddlZddlmZddlmZddlm	Z	d�Z
defd	��YZdS(
sBdistutils.command.build

Implements the Distutils 'build' command.s$Id$i����N(tget_platform(tCommand(tDistutilsOptionErrorcCsddlm}|�dS(Ni����(tshow_compilers(tdistutils.ccompilerR(R((s//usr/lib64/python2.7/distutils/command/build.pyR
stbuildc
Bs�eZdZd,d.d/dd-d	d
fd0d1ddde�fd2d3d4d5gZddgZdd-d efgZd!�Z	d"�Z
d#�Zd$�Zd%�Z
d&�Zd'�Zd(efd)e
fd*efd+efgZRS(6s"build everything needed to installsbuild-base=tbs base directory for build librarysbuild-purelib=s2build directory for platform-neutral distributionssbuild-platlib=s3build directory for platform-specific distributionss
build-lib=s9build directory for all distribution (defaults to either sbuild-purelib or build-platlibsbuild-scripts=sbuild directory for scriptssbuild-temp=ttstemporary build directorys
plat-name=tps6platform name to build for, if supported (default: %s)s	compiler=tcsspecify the compiler typetdebugtgs;compile extensions and libraries with debugging informationtforcetfs2forcibly build everything (ignore file timestamps)sexecutable=tes5specify final destination interpreter path (build.py)s
help-compilerslist available compilerscCsgd|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_dS(NRi(t
build_basetNonet
build_purelibt
build_platlibt	build_libt
build_tempt
build_scriptstcompilert	plat_nameR
Rt
executable(tself((s//usr/lib64/python2.7/distutils/command/build.pytinitialize_options7s										cCs�|jdkrt�|_ntjdkr<td��nd|jtjdd!f}ttd�ru|d7}n|j	dkr�tj
j|jd�|_	n|j
dkr�tj
j|jd|�|_
n|jdkr|jjr�|j
|_q|j	|_n|jdkr=tj
j|jd	|�|_n|jdkrxtj
j|jd
tjdd!�|_n|jdkr�tjr�tj
jtj�|_ndS(NtntsW--plat-name only supported on Windows (try using './configure --help' on your platform)s.%s-%siitgettotalrefcounts-pydebugtlibttempsscripts-(RRRtostnameRtsystversionthasattrRtpathtjoinRRRtdistributiontext_modulesRRRtnormpath(Rtplat_specifier((s//usr/lib64/python2.7/distutils/command/build.pytfinalize_optionsFs2
cCs(x!|j�D]}|j|�q
WdS(N(tget_sub_commandstrun_command(Rtcmd_name((s//usr/lib64/python2.7/distutils/command/build.pytrunxscCs
|jj�S(N(R&thas_pure_modules(R((s//usr/lib64/python2.7/distutils/command/build.pyR/�scCs
|jj�S(N(R&thas_c_libraries(R((s//usr/lib64/python2.7/distutils/command/build.pyR0�scCs
|jj�S(N(R&thas_ext_modules(R((s//usr/lib64/python2.7/distutils/command/build.pyR1�scCs
|jj�S(N(R&thas_scripts(R((s//usr/lib64/python2.7/distutils/command/build.pyR2�stbuild_pyt
build_clibt	build_extR(sbuild-base=Rs base directory for build libraryN(sbuild-purelib=Ns2build directory for platform-neutral distributions(sbuild-platlib=Ns3build directory for platform-specific distributions(sbuild-scripts=Nsbuild directory for scripts(sbuild-temp=Rstemporary build directory(s	compiler=R	sspecify the compiler type(R
Rs;compile extensions and libraries with debugging information(RR
s2forcibly build everything (ignore file timestamps)(sexecutable=Rs5specify final destination interpreter path (build.py)(t__name__t
__module__tdescriptionRRtuser_optionstboolean_optionsRthelp_optionsRR*R.R/R0R1R2tsub_commands(((s//usr/lib64/python2.7/distutils/command/build.pyRsN
			2								(t__doc__t__revision__R!Rtdistutils.utilRtdistutils.coreRtdistutils.errorsRRR(((s//usr/lib64/python2.7/distutils/command/build.pyt<module>s	command/build.pyo000064400000012032151702014350010006 0ustar00�
{fc@swdZdZddlZddlZddlmZddlmZddlm	Z	d�Z
defd	��YZdS(
sBdistutils.command.build

Implements the Distutils 'build' command.s$Id$i����N(tget_platform(tCommand(tDistutilsOptionErrorcCsddlm}|�dS(Ni����(tshow_compilers(tdistutils.ccompilerR(R((s//usr/lib64/python2.7/distutils/command/build.pyR
stbuildc
Bs�eZdZd,d.d/dd-d	d
fd0d1ddde�fd2d3d4d5gZddgZdd-d efgZd!�Z	d"�Z
d#�Zd$�Zd%�Z
d&�Zd'�Zd(efd)e
fd*efd+efgZRS(6s"build everything needed to installsbuild-base=tbs base directory for build librarysbuild-purelib=s2build directory for platform-neutral distributionssbuild-platlib=s3build directory for platform-specific distributionss
build-lib=s9build directory for all distribution (defaults to either sbuild-purelib or build-platlibsbuild-scripts=sbuild directory for scriptssbuild-temp=ttstemporary build directorys
plat-name=tps6platform name to build for, if supported (default: %s)s	compiler=tcsspecify the compiler typetdebugtgs;compile extensions and libraries with debugging informationtforcetfs2forcibly build everything (ignore file timestamps)sexecutable=tes5specify final destination interpreter path (build.py)s
help-compilerslist available compilerscCsgd|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_dS(NRi(t
build_basetNonet
build_purelibt
build_platlibt	build_libt
build_tempt
build_scriptstcompilert	plat_nameR
Rt
executable(tself((s//usr/lib64/python2.7/distutils/command/build.pytinitialize_options7s										cCs�|jdkrt�|_ntjdkr<td��nd|jtjdd!f}ttd�ru|d7}n|j	dkr�tj
j|jd�|_	n|j
dkr�tj
j|jd|�|_
n|jdkr|jjr�|j
|_q|j	|_n|jdkr=tj
j|jd	|�|_n|jdkrxtj
j|jd
tjdd!�|_n|jdkr�tjr�tj
jtj�|_ndS(NtntsW--plat-name only supported on Windows (try using './configure --help' on your platform)s.%s-%siitgettotalrefcounts-pydebugtlibttempsscripts-(RRRtostnameRtsystversionthasattrRtpathtjoinRRRtdistributiontext_modulesRRRtnormpath(Rtplat_specifier((s//usr/lib64/python2.7/distutils/command/build.pytfinalize_optionsFs2
cCs(x!|j�D]}|j|�q
WdS(N(tget_sub_commandstrun_command(Rtcmd_name((s//usr/lib64/python2.7/distutils/command/build.pytrunxscCs
|jj�S(N(R&thas_pure_modules(R((s//usr/lib64/python2.7/distutils/command/build.pyR/�scCs
|jj�S(N(R&thas_c_libraries(R((s//usr/lib64/python2.7/distutils/command/build.pyR0�scCs
|jj�S(N(R&thas_ext_modules(R((s//usr/lib64/python2.7/distutils/command/build.pyR1�scCs
|jj�S(N(R&thas_scripts(R((s//usr/lib64/python2.7/distutils/command/build.pyR2�stbuild_pyt
build_clibt	build_extR(sbuild-base=Rs base directory for build libraryN(sbuild-purelib=Ns2build directory for platform-neutral distributions(sbuild-platlib=Ns3build directory for platform-specific distributions(sbuild-scripts=Nsbuild directory for scripts(sbuild-temp=Rstemporary build directory(s	compiler=R	sspecify the compiler type(R
Rs;compile extensions and libraries with debugging information(RR
s2forcibly build everything (ignore file timestamps)(sexecutable=Rs5specify final destination interpreter path (build.py)(t__name__t
__module__tdescriptionRRtuser_optionstboolean_optionsRthelp_optionsRR*R.R/R0R1R2tsub_commands(((s//usr/lib64/python2.7/distutils/command/build.pyRsN
			2								(t__doc__t__revision__R!Rtdistutils.utilRtdistutils.coreRtdistutils.errorsRRR(((s//usr/lib64/python2.7/distutils/command/build.pyt<module>s	command/build_clib.pyc000064400000014313151702014350010767 0ustar00�
{fc@s{dZdZddlZddlmZddlmZddlmZddl	m
Z
d�Zd	efd
��YZdS(s�distutils.command.build_clib

Implements the Distutils 'build_clib' command, to build a C/C++ library
that is included in the module distribution and needed by an extension
module.s$Id$i����N(tCommand(tDistutilsSetupError(tcustomize_compiler(tlogcCsddlm}|�dS(Ni����(tshow_compilers(tdistutils.ccompilerR(R((s4/usr/lib64/python2.7/distutils/command/build_clib.pyRst
build_clibcBs�eZdZdddddgZdd
gZdddefgZd�Zd�Z	d�Z
d�Zd�Zd�Z
d�ZRS(s/build C/C++ libraries used by Python extensionssbuild-clib=tbs%directory to build C/C++ libraries tosbuild-temp=tts,directory to put temporary build by-productstdebugtgs"compile with debugging informationtforcetfs2forcibly build everything (ignore file timestamps)s	compiler=tcsspecify the compiler types
help-compilerslist available compilerscCsUd|_d|_d|_d|_d|_d|_d|_d|_d|_	dS(Ni(
tNoneRt
build_tempt	librariestinclude_dirstdefinetundefR	Rtcompiler(tself((s4/usr/lib64/python2.7/distutils/command/build_clib.pytinitialize_options6s								cCs�|jdddd	d
d�|jj|_|jrG|j|j�n|jdkrn|jjpeg|_nt|jt�r�|jjt	j
�|_ndS(NtbuildRRRR	R(RR(RR(RR(R	R	(RR(tset_undefined_optionstdistributionRtcheck_library_listRRt
isinstancetstrtsplittostpathsep(R((s4/usr/lib64/python2.7/distutils/command/build_clib.pytfinalize_optionsFs		cCs�|js
dSddlm}|d|jd|jd|j�|_t|j�|jdk	rv|jj	|j�n|j
dk	r�x-|j
D]\}}|jj||�q�Wn|jdk	r�x$|jD]}|jj
|�q�Wn|j|j�dS(Ni����(tnew_compilerRtdry_runR(RRR!RR"RRRRtset_include_dirsRtdefine_macroRtundefine_macrotbuild_libraries(RR!tnametvaluetmacro((s4/usr/lib64/python2.7/distutils/command/build_clib.pytrun_s 		
cCs�t|t�std�nx�|D]�}t|t�rVt|�dkrVtd�n|\}}t|t�s�tdd�nd|ks�tjdkr�tj|kr�tdd|d	�nt|t�s"td
d�q"q"WdS(
s`Ensure that the list of libraries is valid.

`library` is presumably provided as a command option 'libraries'.
        This method checks that it is a list of 2-tuples, where the tuples
        are (library_name, build_info_dict).

Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        s+'libraries' option must be a list of tuplesis*each element of 'libraries' must a 2-tuples+first element of each tuple in 'libraries' s#must be a string (the library name)t/sbad library name '%s': s$may not contain directory separatorsis,second element of each tuple in 'libraries' s!must be a dictionary (build info)N(	RtlistRttupletlenRRtseptdict(RRtlibR't
build_info((s4/usr/lib64/python2.7/distutils/command/build_clib.pyRws*
	
"	
*cCs>|js
dSg}x$|jD]\}}|j|�qW|S(N(RRtappend(Rt	lib_namestlib_nameR2((s4/usr/lib64/python2.7/distutils/command/build_clib.pytget_library_names�s	cCs�|j|j�g}xe|jD]Z\}}|jd�}|dks]t|ttf�rmtd|�n|j|�q W|S(Ntsourcessfin 'libraries' option (library '%s'), 'sources' must be present and must be a list of source filenames(	RRtgetRRR,R-Rtextend(Rt	filenamesR5R2R7((s4/usr/lib64/python2.7/distutils/command/build_clib.pytget_source_files�s"
cCs�x�|D]�\}}|jd�}|dksDt|ttf�r\tddd|�nt|�}tjd|�|jd�}|jd�}|jj	|d|j
d|d|d	|j�}|jj||d|j
d	|j�qWdS(
NR7s&in 'libraries' option (library '%s'), s&'sources' must be present and must be sa list of source filenamessbuilding '%s' librarytmacrosRt
output_dirR	(R8RRR,R-RRtinfoRtcompileRR	tcreate_static_libR(RRR5R2R7R<Rtobjects((s4/usr/lib64/python2.7/distutils/command/build_clib.pyR&�s$"		(sbuild-clib=Rs%directory to build C/C++ libraries to(sbuild-temp=Rs,directory to put temporary build by-products(R	R
s"compile with debugging information(RRs2forcibly build everything (ignore file timestamps)(s	compiler=R
sspecify the compiler typeN(t__name__t
__module__tdescriptiontuser_optionstboolean_optionsRRthelp_optionsRR R*RR6R;R&(((s4/usr/lib64/python2.7/distutils/command/build_clib.pyRs*					$		(
t__doc__t__revision__Rtdistutils.coreRtdistutils.errorsRtdistutils.sysconfigRt	distutilsRRR(((s4/usr/lib64/python2.7/distutils/command/build_clib.pyt<module>s	command/build_clib.pyo000064400000014313151702014350011003 0ustar00�
{fc@s{dZdZddlZddlmZddlmZddlmZddl	m
Z
d�Zd	efd
��YZdS(s�distutils.command.build_clib

`library` is presumably provided as a command option 'libraries'.
        This method checks that it is a list of 2-tuples, where the tuples
        are (library_name, build_info_dict).

Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        s+'libraries' option must be a list of tuplesis*each element of 'libraries' must a 2-tuples+first element of each tuple in 'libraries' s#must be a string (the library name)t/sbad library name '%s': s$may not contain directory separatorsis,second element of each tuple in 'libraries' s!must be a dictionary (build info)N(	RtlistRttupletlenRRtseptdict(RRtlibR't
build_info((s4/usr/lib64/python2.7/distutils/command/build_clib.pyRws*
	
"	
*cCs>|js
dSg}x$|jD]\}}|j|�qW|S(N(RRtappend(Rt	lib_namestlib_nameR2((s4/usr/lib64/python2.7/distutils/command/build_clib.pytget_library_names�s	cCs�|j|j�g}xe|jD]Z\}}|jd�}|dks]t|ttf�rmtd|�n|j|�q W|S(Ntsourcessfin 'libraries' option (library '%s'), 'sources' must be present and must be a list of source filenames(	RRtgetRRR,R-Rtextend(Rt	filenamesR5R2R7((s4/usr/lib64/python2.7/distutils/command/build_clib.pytget_source_files�s"
cCs�x�|D]�\}}|jd�}|dksDt|ttf�r\tddd|�nt|�}tjd|�|jd�}|jd�}|jj	|d|j
d|d|d	|j�}|jj||d|j
d	|j�qWdS(
NR7s&in 'libraries' option (library '%s'), s&'sources' must be present and must be sa list of source filenamessbuilding '%s' librarytmacrosRt
output_dirR	(R8RRR,R-RRtinfoRtcompileRR	tcreate_static_libR(RRR5R2R7R<Rtobjects((s4/usr/lib64/python2.7/distutils/command/build_clib.pyR&�s$"		(sbuild-clib=Rs%directory to build C/C++ libraries to(sbuild-temp=Rs,directory to put temporary build by-products(R	R
s"compile with debugging information(RRs2forcibly build everything (ignore file timestamps)(s	compiler=R
sspecify the compiler typeN(t__name__t
__module__tdescriptiontuser_optionstboolean_optionsRRthelp_optionsRR R*RR6R;R&(((s4/usr/lib64/python2.7/distutils/command/build_clib.pyRs*					$		(
t__doc__t__revision__Rtdistutils.coreRtdistutils.errorsRtdistutils.sysconfigRt	distutilsRRR(((s4/usr/lib64/python2.7/distutils/command/build_clib.pyt<module>s	command/build_ext.pyc000064400000045620151702014350010663 0ustar00�
{fc@s/dZdZddlZddlZddlZddlZddlTddlmZm	Z	ddl
mZddlTddl
mZmZddlmZdd	lmZdd
lmZddlmZejdkr�dd
lmZee��Znejd�Zd�Zdefd��YZ dS(s�distutils.command.build_ext

Implements the Distutils 'build_ext' command, for building extension
modules (currently limited to C extensions, should accommodate C++
extensions ASAP).s$Id$i����N(t*(t	USER_BASEt	USER_SITE(tCommand(tcustomize_compilertget_python_version(tnewer_group(t	Extension(tget_platform(tlogtnt(tget_build_versions3^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$cCsddlm}|�dS(Ni����(tshow_compilers(tdistutils.ccompilerR(R((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR st	build_extcBs?eZdZdejZdFdGdd	d
e�fddd
dfdddefdHdIdJdddefdKdLdMdNdOdQdRdSdTgZdd$d'd-d3gZ	d5dPd6e
fgZd7�Zd8�Z
d9�Zd:�Zd;�Zd<�Zd=�Zd>�Zd?�Zd@�ZdA�ZdB�ZdC�ZdD�ZdE�ZRS(Us8build C/C++ extensions (compile/link to build directory)s (separated by '%s')s
build-lib=tbs(directory for compiled extension modulessbuild-temp=tts1directory for temporary files (build by-products)s
plat-name=tps>platform name to cross-compile for, if supported (default: %s)tinplacetis=ignore build-lib and put compiled extensions into the source s,directory alongside your pure Python moduless
include-dirs=tIs.list of directories to search for header filessdefine=tDsC preprocessor macros to definesundef=tUs!C preprocessor macros to undefines
libraries=tls!external C libraries to link withs
library-dirs=tLs.directories to search for external C librariessrpath=tRs7directories to search for shared C libraries at runtimes
link-objects=tOs2extra explicit link objects to include in the linktdebugtgs'compile/link with debugging informationtforcetfs2forcibly build everything (ignore file timestamps)s	compiler=tcsspecify the compiler typesswig-cpps)make SWIG create C++ files (default is C)s
swig-opts=s!list of SWIG command line optionssswig=spath to the SWIG executabletusers#add user include, library and rpaths
help-compilerslist available compilerscCs�d|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_d|_d|_
d|_d|_d|_d|_d|_d|_d|_dS(Ni(tNonet
extensionst	build_libt	plat_namet
build_tempRtpackagetinclude_dirstdefinetundeft	librariestlibrary_dirstrpathtlink_objectsRRtcompilertswigtswig_cppt	swig_optsR (tself((s3/usr/lib64/python2.7/distutils/command/build_ext.pytinitialize_optionsls(																			c
	Cs�ddlm}|jdd.d/d0d1d2d3�|jdkrP|jj|_n|jj|_|j	�}|j	d
d�}|j
dkr�|jj
p�g|_
nt|j
t�r�|j
j
tj�|_
n|j
j|�||kr|j
j|�n|jd�|jd
�|jdkr5g|_n|jdkrPg|_n3t|j�tkr�tj
|jtj�|_n|jdkr�g|_n3t|j�tkr�tj
|jtj�|_ntjdkr�|jjtjjtjd��|jr)tjj|jd�|_ntjj|jd�|_|j
jtjjtjd��tdkr�|j dkr�d}n
|j d}x�d4d5fD]L}tjjtj|�}|r�tjj||�}n|jj|�q�Wq�tdkr+|jjtjjtjdd��q�tdkr_|jjtjjtjdd��q�|jjtjjtjdd��ntjdkr�|jjtjjtjd��ntj!d  d!ks�tj!d  d"krJtj"j#tjjtjd#��r7|jjtjjtj$d$d%t%�d&��qJ|jjd'�n|j&d(�r�|j's~|jj|j&d)��q�|jjd'�n|j(r�|j(j
d*�}t)d+�|�|_(n|j*r�|j*j
d*�|_*n|j+dkrg|_+n|j+j
d,�|_+|j,r�tjjt-d-�}tjjt-d$�}	tjj.|�rm|j
j|�ntjj.|	�r�|jj|	�|jj|	�q�ndS(6Ni����(t	sysconfigtbuildR#R%R.RRR$t
plat_specificiR*R-R
tlibstDebugtReleasetPCi	twin32titPCbuildsVS9.0isVS8.0isVS7.1tVC6tos2tConfigitcygwintatheostbintlibtpythontconfigt.tPy_ENABLE_SHAREDtLIBDIRt,cSs
|dfS(Nt1((tsymbol((s3/usr/lib64/python2.7/distutils/command/build_ext.pyt<lambda>�R<t tinclude(R#R#(R%R%(R.R.(RR(RR(R$R$(R=(R:sVS9.0(/t	distutilsR4tset_undefined_optionsR&R!tdistributiontext_packagetext_modulesR"tget_python_incR't
isinstancetstrtsplittostpathseptappendtensure_string_listR*R+ttypet
StringTypetstringR,tnametpathtjointsystexec_prefixRR%tMSVC_VERSIONR$tplatformt
executablet
startswithtprefixRtget_config_vartpython_buildR(tmapR)R1R Rtisdir(
R2R4t
py_includetplat_py_includetsuffixtdtnew_libtdefinestuser_includetuser_lib((s3/usr/lib64/python2.7/distutils/command/build_ext.pytfinalize_options�s�

"	"	
%&$

c	Csddlm}|jsdS|jj�rm|jd�}|jj|j�pSg�|j	j
|j�n|d|jd|j
d|jd|j�|_t|j�tjdkr�|jt�kr�|jj|j�n|jdk	r|jj|j�n|jdk	rEx-|jD]\}}|jj||�qWn|jdk	r{x$|jD]}|jj|�q^Wn|jdk	r�|jj|j�n|j	dk	r�|jj|j	�n|jdk	r�|jj |j�n|j!dk	r|jj"|j!�n|j#�dS(	Ni����(tnew_compilert
build_clibR.tverbosetdry_runRR
($R
RwR"RRthas_c_librariestget_finalized_commandR*textendtget_library_namesR+R[RxR.RyRzRRRYR`R$Rt
initializeR'R!tset_include_dirsR(tdefine_macroR)tundefine_macrot
set_librariestset_library_dirsR,tset_runtime_library_dirsR-tset_link_objectstbuild_extensions(R2RwRxR`tvaluetmacro((s3/usr/lib64/python2.7/distutils/command/build_ext.pytruns>			
!c
Cs!t|t�std�nx�t|�D]�\}}t|t�rIq(nt|t�skt|�dkrwtd�n|\}}tjd|�t|t	�o�t
j|�s�td�nt|t�s�td�nt||d�}x<dD]4}|j
|�}|dk	r�t|||�q�q�W|j
d�|_d|krYtjd�n|j
d�}|rg|_g|_x�|D]�}	t|	t�o�t|	�dks�td�nt|	�dkr�|jj|	d�q�t|	�dkr�|jj|	�q�q�Wn|||<q(WdS(s�Ensure that the list of extensions (presumably provided as a
        command option 'extensions') is valid, i.e. it is a list of
        Extension objects.  We also support the old-style list of 2-tuples,
        where the tuples are (ext_name, build_info), which are converted to
        Extension instances here.

Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        s:'ext_modules' option must be a list of Extension instancesisMeach element of 'ext_modules' option must be an Extension instance or 2-tuplesvold-style (ext_name, build_info) tuple found in ext_modules for extension '%s' -- please convert to Extension instancesRfirst element of each tuple in 'ext_modules' must be the extension name (a string)sOsecond element of each tuple in 'ext_modules' must be a dictionary (build info)tsourcesR'R+R*t
extra_objectstextra_compile_argstextra_link_argsR,tdef_files9'def_file' element of build info dict no longer supportedtmacrosis9'macros' element of build info dict must be 1- or 2-tupleiN(R'R+R*R�R�R�(ii(RVtlisttDistutilsSetupErrort	enumerateRttupletlenR	twarnRWtextension_name_retmatchtdicttgetR!tsetattrtruntime_library_dirst
define_macrostundef_macrosR[(
R2R"Rtexttext_namet
build_infotkeytvalR�R�((s3/usr/lib64/python2.7/distutils/command/build_ext.pytcheck_extensions_listVsT
	"				
		
!	cCs>|j|j�g}x!|jD]}|j|j�q W|S(N(R�R"R}R�(R2t	filenamesR�((s3/usr/lib64/python2.7/distutils/command/build_ext.pytget_source_files�s
cCsG|j|j�g}x*|jD]}|j|j|j��q W|S(N(R�R"R[tget_ext_fullpathR`(R2toutputsR�((s3/usr/lib64/python2.7/distutils/command/build_ext.pytget_outputs�s
cCs5|j|j�x|jD]}|j|�qWdS(N(R�R"tbuild_extension(R2R�((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR��sc
Cs�|j}|dks-t|�ttfkrHtddd|j�nt|�}|j|j�}||j	}|j
p�t||d�s�tj
d|j�dStjd|j�|j||�}|jp�g}|j}x!|jD]}|j|f�q�W|jj|d|jd|d	|jd
|j
d|d|j	�}||_|jro|j|j�n|jp{g}|jp�|jj|�}	|jj||d
|j|�d|j d|j!d|d|j"|�d
|j
d|jd|	�dS(Ns*in 'ext_modules' option (extension '%s'), s&'sources' must be present and must be sa list of source filenamestnewers$skipping '%s' extension (up-to-date)sbuilding '%s' extensiont
output_dirR�R'Rtextra_postargstdependsR*R+R�texport_symbolsR%ttarget_lang(#R�R!R]tListTypet	TupleTypeR�R`R�R�R�RRR	Rtinfotswig_sourcesR�R�R�R[R.tcompileR%R't_built_objectsR�R}R�tlanguagetdetect_languagetlink_shared_objectt
get_librariesR+R�tget_export_symbols(
R2R�R�text_pathR�t
extra_argsR�R)tobjectsR�((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR��sN	$

cCs�g}g}i}|jr+tjd�n|jsRd|jksRd|jkr[d}nd}xr|D]j}tjj|�\}}	|	dkr�|j|d|�|j|�|d||<qh|j|�qhW|s�|S|jp�|j	�}
|
dg}|j
|j�|jr*|jd�n|jsWx!|jD]}|j|�q=WnxE|D]=}||}
tjd	||
�|j|d
|
|g�q^W|S(s�Walk the list of source files in 'sources', looking for SWIG
        interface (.i) files.  Run SWIG on all that are found, and
        return a modified 'sources' list with SWIG source files replaced
        by the generated C (or C++) files.
        s/--swig-cpp is deprecated - use --swig-opts=-c++s-c++s.cpps.cs.it_wrapi����s-pythonsswigging %s to %ss-o(
R0R	R�R1RYRatsplitextR[R/t	find_swigR}R�tspawn(R2R�t	extensiontnew_sourcesR�tswig_targetst
target_exttsourcetbaseR�R/tswig_cmdtottarget((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR�s>

cCs�tjdkrdStjdkrixgdD]5}tjjd|d�}tjj|�r)|Sq)WdSn#tjd	kr|dStd
tj�dS(
s�Return the name of the SWIG executable.  On Unix, this is
        just "swig" -- it should be in the PATH.  Tries a bit harder on
        Windows.
        tposixR/R
s1.3s1.2s1.1s	c:\swig%ssswig.exeR?s>I don't know how to find (much less run) SWIG on platform '%s'N(s1.3s1.2s1.1(RYR`RaRbtisfiletDistutilsPlatformError(R2tverstfn((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR�Ps
c	Cs�tjdtjd�}|j|�}|j|�}|jd�}|j|�}tjj|�d}|j	s�tjj
|d |g�}tjj
|j|�Sdj
|dd!�}|jd�}tjj
|j|��}tjj
||�S(s�Returns the path of the filename for a given extension.

The file is located in `build_lib` or directly in the package
        (inplace option).
        t/s..RGi����itbuild_py(R_t	maketransRYtsept	translatetget_ext_fullnameRXtget_ext_filenameRaRRbR#R|tabspathtget_package_dir(	R2R�tall_dotstfullnametmodpathtfilenameR&R�tpackage_dir((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR�qs	cCs&|jdkr|S|jd|SdS(sSReturns the fullname of a given extension name.

Adds the `package.` prefixRGN(R&R!(R2R�((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR��scCs�ddlm}tj|d�}tjdkrZ|t|�dd |t|�d<n|d�}tjdkr�|jr�tjj	|�d	|Stjj	|�t
jr�d	p�d
|S(s�Convert the name of an extension (eg. "foo.bar") into the name
        of the file from which it will be loaded (eg. "foo/bar.so", or
        "foo\bar.pyd").
        i����(RjRGR?iitSOR
t_dR<(tdistutils.sysconfigRjR_RXRYR`R�RRaRbRctpydebug(R2R�RjR�tso_ext((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR��s)cCsCd|jjd�d}||jkr<|jj|�n|jS(sReturn the list of symbols that a shared extension has to
        export.  This either uses 'ext.export_symbols' or, if it's not
        provided, "init" + module_name.  Only relevant on Windows, where
        the .pyd file (DLL) must export the module "init" function.
        tinitRGi����(R`RXR�R[(R2R�t
initfunc_name((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR��scCsqtjdkr�ddlm}t|j|�s}d}|jrM|d}n|tjd?tjd?d@f}|j|gS|jSn�tjd	kr�d}|tjd?tjd?d@f}|j|gStjd
 dkrd}|tjd?tjd?d@f}|j|gStjd
 d
kr�ddl	m
}d}|tjd?tjd?d@f}g}xM|jd�j�D]6}|j
d�r�|j|d�q||j|�q|W|j|dg|Stjdkr�|jStjd dkr�|jSddl	m
}|jd�rfd}|tjd?tjd?d@f}tjrX|d7}n|j|gS|jSdS(s�Return the list of libraries to link against when building a
        shared extension.  On most platforms, this is just 'ext.libraries';
        on Windows and OS/2, we add the Python library (eg. python20.dll).
        R;i����(tMSVCCompilers
python%d%dR�iii�tos2emxiRAspython%d.%dRB(R4tSHLIBSs-litmtdarwinitaixRHN(RcRftdistutils.msvccompilerR�RVR.Rt
hexversionR*RPR4RjRXRhR[R�(R2R�R�ttemplatet	pythonlibR4textraRD((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR��sX

(s
build-lib=Rs(directory for compiled extension modules(sbuild-temp=Rs1directory for temporary files (build by-products)(sdefine=RsC preprocessor macros to define(sundef=Rs!C preprocessor macros to undefine(s
libraries=Rs!external C libraries to link with(srpath=Rs7directories to search for shared C libraries at runtime(s
link-objects=Rs2extra explicit link objects to include in the link(RRs'compile/link with debugging information(RRs2forcibly build everything (ignore file timestamps)(s	compiler=Rsspecify the compiler typeN(sswig-cppNs)make SWIG create C++ files (default is C)(s
swig-opts=Ns!list of SWIG command line options(sswig=Nspath to the SWIG executable(R Ns#add user include, library and rpath(t__name__t
__module__tdescriptionRYRZtsep_byRR!tuser_optionstboolean_optionsRthelp_optionsR3RvR�R�R�R�R�R�R�R�R�R�R�R�R�(((s3/usr/lib64/python2.7/distutils/command/build_ext.pyR%st

�	@	N	
			S	:	!	 				(!t__doc__t__revision__RcRYR_trettypestsiteRRtdistutils.coreRtdistutils.errorsR�RRtdistutils.dep_utilRtdistutils.extensionRtdistutils.utilRRPR	R`R�RtintReR�R�RR(((s3/usr/lib64/python2.7/distutils/command/build_ext.pyt<module>s$0

command/build_ext.pyo000064400000045620151702014350010677 0ustar00�
{fc@s/dZdZddlZddlZddlZddlZddlTddlmZm	Z	ddl
mZddlTddl
mZmZddlmZdd	lmZdd
lmZddlmZejdkr�dd
lmZee��Znejd�Zd�Zdefd��YZ dS(s�distutils.command.build_ext

"	"	
%&$

command/build_py.pyo000064400000026235151702014350010530 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZddlmZm	Z	ddl
mZddlm
Z
d	efd
��YZdS(sHdistutils.command.build_py

Implements the Distutils 'build_py' command.s$Id$i����N(tglob(tCommand(tDistutilsOptionErrortDistutilsFileError(tconvert_path(tlogtbuild_pycBs�eZdZd#d$d&d'd(gZddgZidd6Zd�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd�Zd�Zd�Zd�Zd�Zdd�Zd�Zd �Zd!�Zd"�ZRS()s5"build" pure Python modules (copy to build directory)s
build-lib=tdsdirectory to "build" (copy) totcompiletcscompile .py to .pycs
no-compiles!don't compile .py files [default]s	optimize=tOslalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0]tforcetfs2forcibly build everything (ignore file timestamps)cCsLd|_d|_d|_d|_d|_d|_d|_d|_dS(Ni(	tNonet	build_libt
py_modulestpackagetpackage_datatpackage_dirRtoptimizeR(tself((s2/usr/lib64/python2.7/distutils/command/build_py.pytinitialize_options!s							cCs�|jddd�|jj|_|jj|_|jj|_i|_|jjr�x6|jjj�D]\}}t|�|j|<qhWn|j�|_	t
|jt�s�yt|j�|_Wq�t
tfk
r�td��q�XndS(NtbuildRRsoptimize must be 0, 1, or 2(RR(RR(tset_undefined_optionstdistributiontpackagesRRRtitemsRtget_data_filest
data_filest
isinstanceRtintt
ValueErrortAssertionErrorR(Rtnametpath((s2/usr/lib64/python2.7/distutils/command/build_py.pytfinalize_options+s"		cCsS|jr|j�n|jr6|j�|j�n|j|jdd��dS(Ntinclude_bytecodei(Rt
build_modulesRtbuild_packagestbuild_package_datatbyte_compiletget_outputs(R((s2/usr/lib64/python2.7/distutils/command/build_py.pytrunDs

cCs�g}|js|Sx�|jD]�}|j|�}tjj|jg|jd��}d}|rvt|�d}ng|j||�D]}||^q�}|j	||||f�qW|S(s?Generate list of '(package,src_dir,build_dir,filenames)' tuplest.ii(
Rtget_package_dirtosR"tjoinRtsplittlentfind_data_filestappend(RtdataRtsrc_dirt	build_dirtplentfilet	filenames((s2/usr/lib64/python2.7/distutils/command/build_py.pyRbs	%)cCs�|jjdg�|jj|g�}g}xm|D]e}ttjj|t|���}|jg|D]*}||kritjj|�ri|^qi�q5W|S(s6Return filenames for package's data files in 'src_dir't(	RtgetRR-R"R.Rtextendtisfile(RRR4tglobstfilestpatterntfilelisttfn((s2/usr/lib64/python2.7/distutils/command/build_py.pyR1zs
!#cCs�x�|jD]v\}}}}xa|D]Y}tjj||�}|jtjj|��|jtjj||�|dt�q#Wq
WdS(s$Copy data files into build directoryt
preserve_modeN(RR-R"R.tmkpathtdirnamet	copy_filetFalse(RRR4R5R8tfilenamettarget((s2/usr/lib64/python2.7/distutils/command/build_py.pyR'�s
cCs|jd�}|js5|r.tjj|�SdSn�g}x�|r�y|jdj|�}Wn,tk
r�|jd|d�|d=q>X|jd|�tjj|�Sq>W|jjd�}|dk	r�|jd|�n|r�tjj|�SdSdS(s�Return the directory, relative to the top of the source
           distribution, where package 'package' should be found
           (at least according to the 'package_dir' option, if any).R+R9ii����N(	R/RR-R"R.tKeyErrortinsertR:R
(RRR"ttailtpdir((s2/usr/lib64/python2.7/distutils/command/build_py.pyR,�s(		
	cCs�|dkrYtjj|�s1td|��ntjj|�sYtd|��qYn|r�tjj|d�}tjj|�r�|Stjdd|�ndS(NR9s%package directory '%s' does not exists>supposed package directory '%s' exists, but is not a directorys__init__.pys!package init file '%s' not found s(or not a regular file)(
R-R"texistsRtisdirR.R<RtwarnR
(RRRtinit_py((s2/usr/lib64/python2.7/distutils/command/build_py.pyt
check_package�s	cCs1tjj|�s)tjd||�tStSdS(Ns!file %s (for module %s) not found(R-R"R<RRORFtTrue(Rtmoduletmodule_file((s2/usr/lib64/python2.7/distutils/command/build_py.pytcheck_module�sc	Cs�|j||�ttjj|d��}g}tjj|jj�}xx|D]p}tjj|�}||kr�tjjtjj	|��d}|j
|||f�qP|jd|�qPW|S(Ns*.pyisexcluding %s(RQRR-R"R.tabspathRtscript_nametsplitexttbasenameR2tdebug_print(	RRRtmodule_filestmodulestsetup_scriptRtabs_fRS((s2/usr/lib64/python2.7/distutils/command/build_py.pytfind_package_modules�s
"cCs!i}g}x|jD]}|jd�}dj|dd!�}|d}y||\}}Wn&tk
r�|j|�}d}nX|s�|j||�}	|df||<|	r�|j|d|	f�q�ntjj||d�}
|j	||
�sqn|j|||
f�qW|S(s�Finds individually-specified Python modules, ie. those listed by
        module name in 'self.py_modules'.  Returns a list of tuples (package,
        module_base, filename): 'package' is a tuple of the path through
        package-space to the module; 'module_base' is the bare (no
        packages, no dots) module name, and 'filename' is the path to the
        ".py" file (relative to the distribution root) that implements the
        module.
        R+ii����it__init__s.py(
RR/R.RIR,RQR2R-R"RU(RRR\RSR"Rtmodule_baseRtcheckedRPRT((s2/usr/lib64/python2.7/distutils/command/build_py.pytfind_modules�s*

cCswg}|jr%|j|j��n|jrsxB|jD]4}|j|�}|j||�}|j|�q8Wn|S(s4Compute the list of all modules that will be built, whether
        they are specified one-module-at-a-time ('self.py_modules') or
        by whole packages ('self.packages').  Return a list of tuples
        (package, module, module_file), just like 'find_modules()' and
        'find_package_modules()' do.(RR;RcRR,R_(RR\RRtm((s2/usr/lib64/python2.7/distutils/command/build_py.pytfind_all_moduless		cCs!g|j�D]}|d^q
S(Ni����(Re(RRS((s2/usr/lib64/python2.7/distutils/command/build_py.pytget_source_files-scCs.|gt|�|dg}tjj|�S(Ns.py(tlistR-R"R.(RR5RRStoutfile_path((s2/usr/lib64/python2.7/distutils/command/build_py.pytget_module_outfile0sicCs�|j�}g}x�|D]�\}}}|jd�}|j|j||�}|j|�|r|jr|j|d�n|jdkr�|j|d�q�qqW|g|jD]4\}}}	}
|
D]}tj	j
|	|�^q�q�7}|S(NR+R	ito(ReR/RiRR2RRRR-R"R.(RR$R\toutputsRRSRTRGR4R5R8((s2/usr/lib64/python2.7/distutils/command/build_py.pyR)4s 
	)cCs�t|t�r!|jd�}n$t|ttf�sEtd��n|j|j||�}tj	j
|�}|j|�|j||dd�S(NR+s:'package' must be a string (dot-separated), list, or tupleRBi(
RtstrR/Rgttuplet	TypeErrorRiRR-R"RDRCRE(RRSRTRtoutfiletdir((s2/usr/lib64/python2.7/distutils/command/build_py.pytbuild_moduleIs
cCs=|j�}x*|D]"\}}}|j|||�qWdS(N(RcRq(RR\RRSRT((s2/usr/lib64/python2.7/distutils/command/build_py.pyR%XscCsfx_|jD]T}|j|�}|j||�}x*|D]"\}}}|j|||�q8Wq
WdS(N(RR,R_Rq(RRRR\tpackage_RSRT((s2/usr/lib64/python2.7/distutils/command/build_py.pyR&bs
c
Cs�tjr|jd�dSddlm}|j}|dtjkrV|tj}n|jr�||ddd|j	d|d|j
�n|jdkr�||d|jd|j	d|d|j
�ndS(	Ns%byte-compiling is disabled, skipping.i����(R(RiRtprefixtdry_run(tsystdont_write_bytecodeROtdistutils.utilR(RR-tsepRRRtR(RR>R(Rs((s2/usr/lib64/python2.7/distutils/command/build_py.pyR(ws	
		(s
build-lib=Rsdirectory to "build" (copy) to(RR	scompile .py to .pycN(s
no-compileNs!don't compile .py files [default](s	optimize=R
slalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0](RRs2forcibly build everything (ignore file timestamps)(t__name__t
__module__tdescriptionR
tuser_optionstboolean_optionstnegative_optRR#R*RR1R'R,RQRUR_RcReRfRiR)RqR%R&R((((s2/usr/lib64/python2.7/distutils/command/build_py.pyRs8	
	
				
			(				4					
	(t__doc__t__revision__R-RuRtdistutils.coreRtdistutils.errorsRRRwRt	distutilsRR(((s2/usr/lib64/python2.7/distutils/command/build_py.pyt<module>scommand/build_scripts.py000064400000010766151702014350011412 0ustar00"""distutils.command.build_scripts

Implements the Distutils 'build_scripts' command."""

__revision__ = "$Id$"

import os, re
from stat import ST_MODE
from distutils.core import Command
from distutils.dep_util import newer
from distutils.util import convert_path
from distutils import log

# check if Python is called on the first line with this expression
first_line_re = re.compile('^#!.*python[0-9.]*([ \t].*)?$')

class build_scripts (Command):

description = "\"build\" scripts (copy and fixup #! line)"

user_options = [
        ('build-dir=', 'd', "directory to \"build\" (copy) to"),
        ('force', 'f', "forcibly build everything (ignore file timestamps"),
        ('executable=', 'e', "specify final destination interpreter path"),
        ]

boolean_options = ['force']

def initialize_options (self):
        self.build_dir = None
        self.scripts = None
        self.force = None
        self.executable = None
        self.outfiles = None

def finalize_options (self):
        self.set_undefined_options('build',
                                   ('build_scripts', 'build_dir'),
                                   ('force', 'force'),
                                   ('executable', 'executable'))
        self.scripts = self.distribution.scripts

def get_source_files(self):
        return self.scripts

def run (self):
        if not self.scripts:
            return
        self.copy_scripts()

def copy_scripts (self):
        """Copy each script listed in 'self.scripts'; if it's marked as a
        Python script in the Unix way (first line matches 'first_line_re',
        ie. starts with "\#!" and contains "python"), then adjust the first
        line to refer to the current Python interpreter as we copy.
        """
        _sysconfig = __import__('sysconfig')
        self.mkpath(self.build_dir)
        outfiles = []
        for script in self.scripts:
            adjust = 0
            script = convert_path(script)
            outfile = os.path.join(self.build_dir, os.path.basename(script))
            outfiles.append(outfile)

if not self.force and not newer(script, outfile):
                log.debug("not copying %s (up-to-date)", script)
                continue

# Always open the file, but ignore failures in dry-run mode --
            # that way, we'll get accurate feedback if we can read the
            # script.
            try:
                f = open(script, "r")
            except IOError:
                if not self.dry_run:
                    raise
                f = None
            else:
                first_line = f.readline()
                if not first_line:
                    self.warn("%s is an empty file (skipping)" % script)
                    continue

match = first_line_re.match(first_line)
                if match:
                    adjust = 1
                    post_interp = match.group(1) or ''

if adjust:
                log.info("copying and adjusting %s -> %s", script,
                         self.build_dir)
                if not self.dry_run:
                    outf = open(outfile, "w")
                    if not _sysconfig.is_python_build():
                        outf.write("#!%s%s\n" %
                                   (self.executable,
                                    post_interp))
                    else:
                        outf.write("#!%s%s\n" %
                                   (os.path.join(
                            _sysconfig.get_config_var("BINDIR"),
                           "python%s%s" % (_sysconfig.get_config_var("VERSION"),
                                           _sysconfig.get_config_var("EXE"))),
                                    post_interp))
                    outf.writelines(f.readlines())
                    outf.close()
                if f:
                    f.close()
            else:
                if f:
                    f.close()
                self.copy_file(script, outfile)

if os.name == 'posix':
            for file in outfiles:
                if self.dry_run:
                    log.info("changing mode of %s", file)
                else:
                    oldmode = os.stat(file)[ST_MODE] & 07777
                    newmode = (oldmode | 0555) & 07777
                    if newmode != oldmode:
                        log.info("changing mode of %s from %o to %o",
                                 file, oldmode, newmode)
                        os.chmod(file, newmode)

# copy_scripts ()

# class build_scripts
command/build_scripts.pyc000064400000010575151702014350011553 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZddlm	Z	ddl
mZddlm
Z
ejd	�Zd
efd��YZdS(sRdistutils.command.build_scripts

Implements the Distutils 'build_scripts' command.s$Id$i����N(tST_MODE(tCommand(tnewer(tconvert_path(tlogs^#!.*python[0-9.]*([ 	].*)?$t
build_scriptscBsSeZdZdddgZdgZd
�Zd�Zd�Zd
�Zd�Z	RS(s("build" scripts (copy and fixup #! line)s
build-dir=tdsdirectory to "build" (copy) totforcetfs1forcibly build everything (ignore file timestampssexecutable=tes*specify final destination interpreter pathcCs1d|_d|_d|_d|_d|_dS(N(tNonet	build_dirtscriptsRt
executabletoutfiles(tself((s7/usr/lib64/python2.7/distutils/command/build_scripts.pytinitialize_optionss
				cCs)|jdddd�|jj|_dS(	NtbuildRRRR
(RR(RR(R
R
(tset_undefined_optionstdistributionR(R((s7/usr/lib64/python2.7/distutils/command/build_scripts.pytfinalize_options%s
	cCs|jS(N(R(R((s7/usr/lib64/python2.7/distutils/command/build_scripts.pytget_source_files,scCs|js
dS|j�dS(N(Rtcopy_scripts(R((s7/usr/lib64/python2.7/distutils/command/build_scripts.pytrun/s	c	Cs�td�}|j|j�g}x|jD]}d}t|�}tjj|jtjj|��}|j	|�|j
r�t||�r�tj
d|�q,nyt|d�}Wn&tk
r�|js��nd}n]X|j�}|s
|jd|�q,ntj|�}|r=d}|jd�p7d}	n|rtjd||j�|jst|d	�}
|j�s�|
jd
|j|	f�nK|
jd
tjj|jd�d|jd
�|jd�f�|	f�|
j|j��|
j�n|r>|j�q>q,|r.|j�n|j||�q,Wtj dkr�x�|D]|}|jrztjd|�qXtj!|�t"d@}|dBd@}
|
|krXtjd|||
�tj#||
�qXqXWndS(s"Copy each script listed in 'self.scripts'; if it's marked as a
        Python script in the Unix way (first line matches 'first_line_re',
        ie. starts with "\#!" and contains "python"), then adjust the first
        line to refer to the current Python interpreter as we copy.
        t	sysconfigisnot copying %s (up-to-date)trs%s is an empty file (skipping)itscopying and adjusting %s -> %stws#!%s%s
tBINDIRs
python%s%stVERSIONtEXEtposixschanging mode of %si�ims!changing mode of %s from %o to %oN($t
__import__tmkpathRRRtostpathtjointbasenametappendRRRtdebugtopentIOErrortdry_runR
treadlinetwarnt
first_line_retmatchtgrouptinfotis_python_buildtwriteR
tget_config_vart
writelinest	readlinestcloset	copy_filetnametstatRtchmod(Rt
_sysconfigRtscripttadjusttoutfileRt
first_lineR.tpost_interptoutftfiletoldmodetnewmode((s7/usr/lib64/python2.7/distutils/command/build_scripts.pyR5sr$

(s
build-dir=Rsdirectory to "build" (copy) to(RRs1forcibly build everything (ignore file timestamps(sexecutable=R	s*specify final destination interpreter path(
t__name__t
__module__tdescriptiontuser_optionstboolean_optionsRRRRR(((s7/usr/lib64/python2.7/distutils/command/build_scripts.pyRs						(t__doc__t__revision__R"treR9Rtdistutils.coreRtdistutils.dep_utilRtdistutils.utilRt	distutilsRtcompileR-R(((s7/usr/lib64/python2.7/distutils/command/build_scripts.pyt<module>scommand/build_scripts.pyo000064400000010575151702014350011567 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZddlm	Z	ddl
mZddlm
Z
ejd	�Zd
efd��YZdS(sRdistutils.command.build_scripts

(s
build-dir=Rsdirectory to "build" (copy) to(RRs1forcibly build everything (ignore file timestamps(sexecutable=R	s*specify final destination interpreter path(
t__name__t
__module__tdescriptiontuser_optionstboolean_optionsRRRRR(((s7/usr/lib64/python2.7/distutils/command/build_scripts.pyRs						(t__doc__t__revision__R"treR9Rtdistutils.coreRtdistutils.dep_utilRtdistutils.utilRt	distutilsRtcompileR-R(((s7/usr/lib64/python2.7/distutils/command/build_scripts.pyt<module>scommand/clean.pyc000064400000005775151702014350007775 0ustar00�
{fc@sbdZdZddlZddlmZddlmZddlmZdefd��YZ	dS(	sBdistutils.command.clean

Implements the Distutils 'clean' command.s$Id$i����N(tCommand(tremove_tree(tlogtcleancBsJeZdZddddddgZd
gZd�Zd�Zd�ZRS(s-clean up temporary files from 'build' commandsbuild-base=tbs2base build directory (default: 'build.build-base')s
build-lib=s<build directory for all modules (default: 'build.build-lib')sbuild-temp=tts7temporary build directory (default: 'build.build-temp')sbuild-scripts=s<build directory for scripts (default: 'build.build-scripts')sbdist-base=s+temporary directory for built distributionstalltas7remove all build output, not just temporary by-productscCs:d|_d|_d|_d|_d|_d|_dS(N(tNonet
build_baset	build_libt
build_tempt
build_scriptst
bdist_baseR(tself((s//usr/lib64/python2.7/distutils/command/clean.pytinitialize_options"s					cCs-|jddd	d
d�|jdd�dS(
NtbuildR	R
RRtbdistR
(R	R	(R
R
(RR(RR(R
R
(tset_undefined_options(R((s//usr/lib64/python2.7/distutils/command/clean.pytfinalize_options*s		cCs�tjj|j�r.t|jd|j�ntjd|j�|jr�x[|j	|j
|jfD]>}tjj|�r�t|d|j�qctjd|�qcWn|js�y'tj
|j�tjd|j�Wq�tk
r�q�XndS(Ntdry_runs%'%s' does not exist -- can't clean its
removing '%s'(tostpathtexistsRRRRtdebugRR
R
RtwarntrmdirR	tinfotOSError(Rt	directory((s//usr/lib64/python2.7/distutils/command/clean.pytrun3s$	
				
(sbuild-base=Rs2base build directory (default: 'build.build-base')N(s
build-lib=Ns<build directory for all modules (default: 'build.build-lib')(sbuild-temp=Rs7temporary build directory (default: 'build.build-temp')(sbuild-scripts=Ns<build directory for scripts (default: 'build.build-scripts')(sbdist-base=Ns+temporary directory for built distributions(RRs7remove all build output, not just temporary by-products(	t__name__t
__module__tdescriptionRtuser_optionstboolean_optionsRRR(((s//usr/lib64/python2.7/distutils/command/clean.pyRs"					(
t__doc__t__revision__Rtdistutils.coreRtdistutils.dir_utilRt	distutilsRR(((s//usr/lib64/python2.7/distutils/command/clean.pyt<module>scommand/config.py000064400000031512151702014350010001 0ustar00"""distutils.command.config

__revision__ = "$Id$"

import os
import re

from distutils.core import Command
from distutils.errors import DistutilsExecError
from distutils.sysconfig import customize_compiler
from distutils import log

LANG_EXT = {'c': '.c', 'c++': '.cxx'}

class config(Command):

description = "prepare to build"

user_options = [
        ('compiler=', None,
         "specify the compiler type"),
        ('cc=', None,
         "specify the compiler executable"),
        ('include-dirs=', 'I',
         "list of directories to search for header files"),
        ('define=', 'D',
         "C preprocessor macros to define"),
        ('undef=', 'U',
         "C preprocessor macros to undefine"),
        ('libraries=', 'l',
         "external C libraries to link with"),
        ('library-dirs=', 'L',
         "directories to search for external C libraries"),

('noisy', None,
         "show every action (compile, link, run, ...) taken"),
        ('dump-source', None,
         "dump generated source files before attempting to compile them"),
        ]

# The three standard command methods: since the "config" command
    # does nothing by default, these are empty.

def initialize_options(self):
        self.compiler = None
        self.cc = None
        self.include_dirs = None
        self.libraries = None
        self.library_dirs = None

# maximal output for now
        self.noisy = 1
        self.dump_source = 1

# list of temporary files generated along-the-way that we have
        # to clean at some point
        self.temp_files = []

def finalize_options(self):
        if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        elif isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

if self.libraries is None:
            self.libraries = []
        elif isinstance(self.libraries, str):
            self.libraries = [self.libraries]

if self.library_dirs is None:
            self.library_dirs = []
        elif isinstance(self.library_dirs, str):
            self.library_dirs = self.library_dirs.split(os.pathsep)

def run(self):
        pass

# Utility methods for actual "config" commands.  The interfaces are
    # loosely based on Autoconf macros of similar names.  Sub-classes
    # may use these freely.

def _check_compiler(self):
        """Check that 'self.compiler' really is a CCompiler object;
        if not, make it one.
        """
        # We do this late, and only on-demand, because this is an expensive
        # import.
        from distutils.ccompiler import CCompiler, new_compiler
        if not isinstance(self.compiler, CCompiler):
            self.compiler = new_compiler(compiler=self.compiler,
                                         dry_run=self.dry_run, force=1)
            customize_compiler(self.compiler)
            if self.include_dirs:
                self.compiler.set_include_dirs(self.include_dirs)
            if self.libraries:
                self.compiler.set_libraries(self.libraries)
            if self.library_dirs:
                self.compiler.set_library_dirs(self.library_dirs)

def _gen_temp_sourcefile(self, body, headers, lang):
        filename = "_configtest" + LANG_EXT[lang]
        file = open(filename, "w")
        if headers:
            for header in headers:
                file.write("#include <%s>\n" % header)
            file.write("\n")
        file.write(body)
        if body[-1] != "\n":
            file.write("\n")
        file.close()
        return filename

def _preprocess(self, body, headers, include_dirs, lang):
        src = self._gen_temp_sourcefile(body, headers, lang)
        out = "_configtest.i"
        self.temp_files.extend([src, out])
        self.compiler.preprocess(src, out, include_dirs=include_dirs)
        return (src, out)

def _compile(self, body, headers, include_dirs, lang):
        src = self._gen_temp_sourcefile(body, headers, lang)
        if self.dump_source:
            dump_file(src, "compiling '%s':" % src)
        (obj,) = self.compiler.object_filenames([src])
        self.temp_files.extend([src, obj])
        self.compiler.compile([src], include_dirs=include_dirs)
        return (src, obj)

def _link(self, body, headers, include_dirs, libraries, library_dirs,
              lang):
        (src, obj) = self._compile(body, headers, include_dirs, lang)
        prog = os.path.splitext(os.path.basename(src))[0]
        self.compiler.link_executable([obj], prog,
                                      libraries=libraries,
                                      library_dirs=library_dirs,
                                      target_lang=lang)

if self.compiler.exe_extension is not None:
            prog = prog + self.compiler.exe_extension
        self.temp_files.append(prog)

return (src, obj, prog)

def _clean(self, *filenames):
        if not filenames:
            filenames = self.temp_files
            self.temp_files = []
        log.info("removing: %s", ' '.join(filenames))
        for filename in filenames:
            try:
                os.remove(filename)
            except OSError:
                pass

# XXX these ignore the dry-run flag: what to do, what to do? even if
    # you want a dry-run build, you still need some sort of configuration
    # info.  My inclination is to make it up to the real config command to
    # consult 'dry_run', and assume a default (minimal) configuration if
    # true.  The problem with trying to do it here is that you'd have to
    # return either true or false from all the 'try' methods, neither of
    # which is correct.

# XXX need access to the header search path and maybe default macros.

def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"):
        """Construct a source file from 'body' (a string containing lines
        of C/C++ code) and 'headers' (a list of header files to include)
        and run it through the preprocessor.  Return true if the
        preprocessor succeeded, false if there were any errors.
        ('body' probably isn't of much use, but what the heck.)
        """
        from distutils.ccompiler import CompileError
        self._check_compiler()
        ok = 1
        try:
            self._preprocess(body, headers, include_dirs, lang)
        except CompileError:
            ok = 0

self._clean()
        return ok

def search_cpp(self, pattern, body=None, headers=None, include_dirs=None,
                   lang="c"):
        """Construct a source file (just like 'try_cpp()'), run it through
        the preprocessor, and return true if any line of the output matches
        'pattern'.  'pattern' should either be a compiled regex object or a
        string containing a regex.  If both 'body' and 'headers' are None,
        preprocesses an empty file -- which can be useful to determine the
        symbols the preprocessor and compiler set by default.
        """
        self._check_compiler()
        src, out = self._preprocess(body, headers, include_dirs, lang)

if isinstance(pattern, str):
            pattern = re.compile(pattern)

file = open(out)
        match = 0
        while 1:
            line = file.readline()
            if line == '':
                break
            if pattern.search(line):
                match = 1
                break

file.close()
        self._clean()
        return match

def try_compile(self, body, headers=None, include_dirs=None, lang="c"):
        """Try to compile a source file built from 'body' and 'headers'.
        Return true on success, false otherwise.
        """
        from distutils.ccompiler import CompileError
        self._check_compiler()
        try:
            self._compile(body, headers, include_dirs, lang)
            ok = 1
        except CompileError:
            ok = 0

log.info(ok and "success!" or "failure.")
        self._clean()
        return ok

def try_link(self, body, headers=None, include_dirs=None, libraries=None,
                 library_dirs=None, lang="c"):
        """Try to compile and link a source file, built from 'body' and
        'headers', to executable form.  Return true on success, false
        otherwise.
        """
        from distutils.ccompiler import CompileError, LinkError
        self._check_compiler()
        try:
            self._link(body, headers, include_dirs,
                       libraries, library_dirs, lang)
            ok = 1
        except (CompileError, LinkError):
            ok = 0

log.info(ok and "success!" or "failure.")
        self._clean()
        return ok

def try_run(self, body, headers=None, include_dirs=None, libraries=None,
                library_dirs=None, lang="c"):
        """Try to compile, link to an executable, and run a program
        built from 'body' and 'headers'.  Return true on success, false
        otherwise.
        """
        from distutils.ccompiler import CompileError, LinkError
        self._check_compiler()
        try:
            src, obj, exe = self._link(body, headers, include_dirs,
                                       libraries, library_dirs, lang)
            self.spawn([exe])
            ok = 1
        except (CompileError, LinkError, DistutilsExecError):
            ok = 0

log.info(ok and "success!" or "failure.")
        self._clean()
        return ok

# -- High-level methods --------------------------------------------
    # (these are the ones that are actually likely to be useful
    # when implementing a real-world config command!)

def check_func(self, func, headers=None, include_dirs=None,
                   libraries=None, library_dirs=None, decl=0, call=0):

"""Determine if function 'func' is available by constructing a
        source file that refers to 'func', and compiles and links it.
        If everything succeeds, returns true; otherwise returns false.

The constructed source file starts out by including the header
        files listed in 'headers'.  If 'decl' is true, it then declares
        'func' (as "int func()"); you probably shouldn't supply 'headers'
        and set 'decl' true in the same call, or you might get errors about
        a conflicting declarations for 'func'.  Finally, the constructed
        'main()' function either references 'func' or (if 'call' is true)
        calls it.  'libraries' and 'library_dirs' are used when
        linking.
        """

self._check_compiler()
        body = []
        if decl:
            body.append("int %s ();" % func)
        body.append("int main () {")
        if call:
            body.append("  %s();" % func)
        else:
            body.append("  %s;" % func)
        body.append("}")
        body = "\n".join(body) + "\n"

return self.try_link(body, headers, include_dirs,
                             libraries, library_dirs)

# check_func ()

def check_lib(self, library, library_dirs=None, headers=None,
                  include_dirs=None, other_libraries=[]):
        """Determine if 'library' is available to be linked against,
        without actually checking that any particular symbols are provided
        by it.  'headers' will be used in constructing the source file to
        be compiled, but the only effect of this is to check if all the
        header files listed are available.  Any libraries listed in
        'other_libraries' will be included in the link, in case 'library'
        has symbols that depend on other libraries.
        """
        self._check_compiler()
        return self.try_link("int main (void) { }",
                             headers, include_dirs,
                             [library]+other_libraries, library_dirs)

def check_header(self, header, include_dirs=None, library_dirs=None,
                     lang="c"):
        """Determine if the system header file named by 'header_file'
        exists and can be found by the preprocessor; return true if so,
        false otherwise.
        """
        return self.try_cpp(body="/* No body */", headers=[header],
                            include_dirs=include_dirs)

def dump_file(filename, head=None):
    """Dumps a file content into log.info.

If head is not None, will be dumped before the file content.
    """
    if head is None:
        log.info('%s' % filename)
    else:
        log.info(head)
    file = open(filename)
    try:
        log.info(file.read())
    finally:
        file.close()
command/config.pyc000064400000030615151702014350010147 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZddlm	Z	ddl
mZidd	6d
d6Zdefd
��YZ
ed�ZdS(s�distutils.command.config

Implements the Distutils 'config' command, a (mostly) empty command class
that exists mainly to be sub-classed by specific module distributions and
applications.  The idea is that while every "config" command is different,
at least they're all named the same, and users always see "config" in the
list of standard commands.  Also, this is a good place to put common
configure-like tasks: "try to compile this C code", or "figure out where
this header file lives".
s$Id$i����N(tCommand(tDistutilsExecError(tcustomize_compiler(tlogs.ctcs.cxxsc++tconfigcBs.eZdZd,d-d.d/d0d1d2d3d4g	Zd�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd�Zd �Z
d+d+d+d!d"�Zd+d+d+d!d#�Zd+d+d!d$�Zd+d+d+d+d!d%�Zd+d+d+d+d!d&�Zd+d+d+d+d'd'd(�Zd+d+d+gd)�Zd+d+d!d*�ZRS(5sprepare to builds	compiler=sspecify the compiler typescc=sspecify the compiler executables
include-dirs=tIs.list of directories to search for header filessdefine=tDsC preprocessor macros to definesundef=tUs!C preprocessor macros to undefines
libraries=tls!external C libraries to link withs
library-dirs=tLs.directories to search for external C librariestnoisys1show every action (compile, link, run, ...) takensdump-sources=dump generated source files before attempting to compile themcCsLd|_d|_d|_d|_d|_d|_d|_g|_dS(Ni(	tNonetcompilertcctinclude_dirst	librariestlibrary_dirsRtdump_sourcet
temp_files(tself((s0/usr/lib64/python2.7/distutils/command/config.pytinitialize_options6s							cCs�|jdkr'|jjpg|_n-t|jt�rT|jjtj�|_n|jdkrog|_n$t|jt�r�|jg|_n|j	dkr�g|_	n-t|j	t�r�|j	jtj�|_	ndS(N(
RRtdistributiont
isinstancetstrtsplittostpathsepRR(R((s0/usr/lib64/python2.7/distutils/command/config.pytfinalize_optionsEscCsdS(N((R((s0/usr/lib64/python2.7/distutils/command/config.pytrunUscCs�ddlm}m}t|j|�s�|d|jd|jdd�|_t|j�|jrx|jj|j�n|j	r�|jj
|j	�n|jr�|jj|j�q�ndS(s^Check that 'self.compiler' really is a CCompiler object;
        if not, make it one.
        i����(t	CCompilertnew_compilerR
tdry_runtforceiN(
tdistutils.ccompilerRRRR
R RRtset_include_dirsRt
set_librariesRtset_library_dirs(RRR((s0/usr/lib64/python2.7/distutils/command/config.pyt_check_compiler]s
			cCs�dt|}t|d�}|rUx|D]}|jd|�q*W|jd�n|j|�|ddkr�|jd�n|j�|S(Nt_configtesttws#include <%s>
s
i����(tLANG_EXTtopentwritetclose(Rtbodytheaderstlangtfilenametfiletheader((s0/usr/lib64/python2.7/distutils/command/config.pyt_gen_temp_sourcefileps

cCsT|j|||�}d}|jj||g�|jj||d|�||fS(Ns
_configtest.iR(R3RtextendR
t
preprocess(RR-R.RR/tsrctout((s0/usr/lib64/python2.7/distutils/command/config.pyt_preprocess}s
cCs�|j|||�}|jr2t|d|�n|jj|g�\}|jj||g�|jj|gd|�||fS(Nscompiling '%s':R(R3Rt	dump_fileR
tobject_filenamesRR4tcompile(RR-R.RR/R6tobj((s0/usr/lib64/python2.7/distutils/command/config.pyt_compile�s	c
	Cs�|j||||�\}}tjjtjj|��d}	|jj|g|	d|d|d|�|jjdk	r�|	|jj}	n|j	j
|	�|||	fS(NiRRttarget_lang(R=RtpathtsplitexttbasenameR
tlink_executablet
exe_extensionRRtappend(
RR-R.RRRR/R6R<tprog((s0/usr/lib64/python2.7/distutils/command/config.pyt_link�s"cGsn|s|j}g|_ntjddj|��x3|D]+}ytj|�Wq;tk
req;Xq;WdS(Nsremoving: %st (RRtinfotjoinRtremovetOSError(Rt	filenamesR0((s0/usr/lib64/python2.7/distutils/command/config.pyt_clean�s

RcCsbddlm}|j�d}y|j||||�Wn|k
rSd}nX|j�|S(sQConstruct a source file from 'body' (a string containing lines
        of C/C++ code) and 'headers' (a list of header files to include)
        and run it through the preprocessor.  Return true if the
        preprocessor succeeded, false if there were any errors.
        ('body' probably isn't of much use, but what the heck.)
        i����(tCompileErrorii(R"RNR&R8RM(RR-R.RR/RNtok((s0/usr/lib64/python2.7/distutils/command/config.pyttry_cpp�s

cCs�|j�|j||||�\}}t|t�rItj|�}nt|�}d}	x9|j�}
|
dkrzPn|j|
�r^d}	Pq^q^W|j	�|j
�|	S(s�Construct a source file (just like 'try_cpp()'), run it through
        the preprocessor, and return true if any line of the output matches
        'pattern'.  'pattern' should either be a compiled regex object or a
        string containing a regex.  If both 'body' and 'headers' are None,
        preprocesses an empty file -- which can be useful to determine the
        symbols the preprocessor and compiler set by default.
        iti(R&R8RRtreR;R*treadlinetsearchR,RM(RtpatternR-R.RR/R6R7R1tmatchtline((s0/usr/lib64/python2.7/distutils/command/config.pyt
search_cpp�s

cCs{ddlm}|j�y |j||||�d}Wn|k
rSd}nXtj|rfdpid�|j�|S(swTry to compile a source file built from 'body' and 'headers'.
        Return true on success, false otherwise.
        i����(RNiissuccess!sfailure.(R"RNR&R=RRHRM(RR-R.RR/RNRO((s0/usr/lib64/python2.7/distutils/command/config.pyttry_compile�s

c
Cs�ddlm}m}|j�y&|j||||||�d}	Wn||fk
red}	nXtj|	rxdp{d�|j�|	S(s�Try to compile and link a source file, built from 'body' and
        'headers', to executable form.  Return true on success, false
        otherwise.
        i����(RNt	LinkErroriissuccess!sfailure.(R"RNRZR&RFRRHRM(
RR-R.RRRR/RNRZRO((s0/usr/lib64/python2.7/distutils/command/config.pyttry_link�s

c
Cs�ddlm}m}|j�yA|j||||||�\}	}
}|j|g�d}Wn ||tfk
r�d}nXtj|r�dp�d�|j	�|S(s�Try to compile, link to an executable, and run a program
        built from 'body' and 'headers'.  Return true on success, false
        otherwise.
        i����(RNRZiissuccess!sfailure.(
R"RNRZR&RFtspawnRRRHRM(
RR-R.RRRR/RNRZR6R<texeRO((s0/usr/lib64/python2.7/distutils/command/config.pyttry_runs

ic	Cs�|j�g}|r*|jd|�n|jd�|rQ|jd|�n|jd|�|jd�dj|�d}|j|||||�S(s�Determine if function 'func' is available by constructing a
        source file that refers to 'func', and compiles and links it.
        If everything succeeds, returns true; otherwise returns false.

cCs*|j�|jd|||g||�S(s�Determine if 'library' is available to be linked against,
        without actually checking that any particular symbols are provided
        by it.  'headers' will be used in constructing the source file to
        be compiled, but the only effect of this is to check if all the
        header files listed are available.  Any libraries listed in
        'other_libraries' will be included in the link, in case 'library'
        has symbols that depend on other libraries.
        sint main (void) { }(R&R[(RtlibraryRR.Rtother_libraries((s0/usr/lib64/python2.7/distutils/command/config.pyt	check_lib?s

cCs|jddd|gd|�S(s�Determine if the system header file named by 'header_file'
        exists and can be found by the preprocessor; return true if so,
        false otherwise.
        R-s
/* No body */R.R(RP(RR2RRR/((s0/usr/lib64/python2.7/distutils/command/config.pytcheck_headerNsN(s	compiler=Nsspecify the compiler type(scc=Nsspecify the compiler executable(s
include-dirs=Rs.list of directories to search for header files(sdefine=RsC preprocessor macros to define(sundef=Rs!C preprocessor macros to undefine(s
libraries=R	s!external C libraries to link with(s
library-dirs=R
s.directories to search for external C libraries(RNs1show every action (compile, link, run, ...) taken(sdump-sourceNs=dump generated source files before attempting to compile them(t__name__t
__module__tdescriptionRtuser_optionsRRRR&R3R8R=RFRMRPRXRYR[R^RcRfRg(((s0/usr/lib64/python2.7/distutils/command/config.pyRsT						
								!cCsb|dkr tjd|�n
tj|�t|�}ztj|j��Wd|j�XdS(sjDumps a file content into log.info.

If head is not None, will be dumped before the file content.
    s%sN(RRRHR*treadR,(R0theadR1((s0/usr/lib64/python2.7/distutils/command/config.pyR9Xs
(t__doc__t__revision__RRRtdistutils.coreRtdistutils.errorsRtdistutils.sysconfigRt	distutilsRR)RRR9(((s0/usr/lib64/python2.7/distutils/command/config.pyt<module>
s�Acommand/config.pyo000064400000030615151702014350010163 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZddlm	Z	ddl
mZidd	6d
d6Zdefd
��YZ
ed�ZdS(s�distutils.command.config

If head is not None, will be dumped before the file content.
    s%sN(RRRHR*treadR,(R0theadR1((s0/usr/lib64/python2.7/distutils/command/config.pyR9Xs
(t__doc__t__revision__RRRtdistutils.coreRtdistutils.errorsRtdistutils.sysconfigRt	distutilsRR)RRR9(((s0/usr/lib64/python2.7/distutils/command/config.pyt<module>
s�Acommand/install_data.pyc000064400000006056151702014350011343 0ustar00�
{fc@sXdZdZddlZddlmZddlmZmZdefd��YZdS(s�distutils.command.install_data

Implements the Distutils 'install_data' command, for installing
platform-independent data files.s$Id$i����N(tCommand(tchange_roottconvert_pathtinstall_datacBsSeZdZdddgZdgZd	�Zd
�Zd�Zd�Z	d
�Z
RS(sinstall data filessinstall-dir=tdsIbase directory for installing data files (default: installation base dir)sroot=s<install everything relative to this alternate root directorytforcetfs-force installation (overwrite existing files)cCs@d|_g|_d|_d|_|jj|_d|_dS(Nii(tNonetinstall_dirtoutfilestrootRtdistributiont
data_filestwarn_dir(tself((s6/usr/lib64/python2.7/distutils/command/install_data.pytinitialize_optionss				cCs|jdddd�dS(	NtinstallRRR
R(RR(R
R
(RR(tset_undefined_options(R((s6/usr/lib64/python2.7/distutils/command/install_data.pytfinalize_options%s	cCsk|j|j�xT|jD]I}t|t�r�t|�}|jra|jd||jf�n|j||j�\}}|j	j
|�qt|d�}tjj
|�s�tjj|j|�}n|jr�t|j|�}n|j|�|dgkr|j	j
|�qxF|dD]:}t|�}|j||�\}}|j	j
|�q%WqWdS(NsMsetup script did not provide a directory for '%s' -- installing right in '%s'ii(tmkpathRRt
isinstancetstrRR
twarnt	copy_fileR	tappendtostpathtisabstjoinR
R(RRtoutt_tdirtdata((s6/usr/lib64/python2.7/distutils/command/install_data.pytrun,s*			
cCs
|jpgS(N(R(R((s6/usr/lib64/python2.7/distutils/command/install_data.pyt
get_inputsMscCs|jS(N(R	(R((s6/usr/lib64/python2.7/distutils/command/install_data.pytget_outputsPs(sinstall-dir=RsIbase directory for installing data files (default: installation base dir)N(sroot=Ns<install everything relative to this alternate root directory(RRs-force installation (overwrite existing files)(t__name__t
__module__tdescriptionRtuser_optionstboolean_optionsRRR!R"R#(((s6/usr/lib64/python2.7/distutils/command/install_data.pyRs					!	(	t__doc__t__revision__Rtdistutils.coreRtdistutils.utilRRR(((s6/usr/lib64/python2.7/distutils/command/install_data.pyt<module>s
command/install_egg_info.pyc000064400000007240151702014350012203 0ustar00�
{fc@s�dZddlmZddlmZmZddlZddlZddlZdefd��YZ	d�Z
d�Zd	�ZdS(
s�distutils.command.install_egg_info

Implements the Distutils 'install_egg_info' command, for installing
a package's PKG-INFO metadata.i����(tCommand(tlogtdir_utilNtinstall_egg_infocBsAeZdZdZd	gZd�Zd�Zd�Zd�ZRS(
s)Install an .egg-info file for the packages8Install package's PKG-INFO metadata as an .egg-info filesinstall-dir=tdsdirectory to install tocCs
d|_dS(N(tNonetinstall_dir(tself((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pytinitialize_optionsscCs�|jdd�dtt|jj���tt|jj���tjd f}t	j
j|j|�|_
|j
g|_dS(Ntinstall_libRs%s-%s-py%s.egg-infoi(RR(tset_undefined_optionstto_filenamet	safe_nametdistributiontget_nametsafe_versiontget_versiontsystversiontostpathtjoinRttargettoutputs(Rtbasename((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pytfinalize_optionsscCs|j}tjj|�rGtjj|�rGtj|d|j�nptjj|�r||j	tj
|jfd|�n;tjj|j�s�|j	tj|jfd|j�nt
jd|�|js�t|d�}|jjj|�|j�ndS(Ntdry_runs	Removing s	Creating s
Writing %stw(RRRtisdirtislinkRtremove_treeRtexiststexecutetunlinkRtmakedirsRtinfotopenR
tmetadatatwrite_pkg_filetclose(RRtf((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pytrun s	%#	cCs|jS(N(R(R((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pytget_outputs/s(sinstall-dir=Rsdirectory to install to(	t__name__t
__module__t__doc__tdescriptiontuser_optionsRRR)R*(((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pyRs			
	cCstjdd|�S(s�Convert an arbitrary string to a standard distribution name

Any runs of non-alphanumeric/. characters are replaced with a single '-'.
    s[^A-Za-z0-9.]+t-(tretsub(tname((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pyR7scCs%|jdd�}tjdd|�S(s�Convert an arbitrary string to a standard version string

Spaces become dots, and all other non-alphanumeric characters become
    dashes, with runs of multiple dashes condensed to a single dash.
    t t.s[^A-Za-z0-9.]+R0(treplaceR1R2(R((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pyR?scCs|jdd�S(s|Convert a project or version name to its filename-escaped form

Any '-' characters are currently replaced with '_'.
    R0t_(R6(R3((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pyRIs(
R-t
distutils.cmdRt	distutilsRRRRR1RRRR(((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pyt<module>s$,		
command/install_headers.pyc000064400000004317151702014350012043 0ustar00�
{fc@s6dZdZddlmZdefd��YZdS(s�distutils.command.install_headers

Implements the Distutils 'install_headers' command, to install C/C++ header
files to the Python include directory.s$Id$i����(tCommandtinstall_headerscBsPeZdZdd
gZdgZd�Zd�Zd	�Zd
�Zd�Z	RS(sinstall C/C++ header filessinstall-dir=tds$directory to install header files totforcetfs-force installation (overwrite existing files)cCsd|_d|_g|_dS(Ni(tNonetinstall_dirRtoutfiles(tself((s9/usr/lib64/python2.7/distutils/command/install_headers.pytinitialize_optionss		cCs|jddd�dS(NtinstallRRR(RR(RR(tset_undefined_options(R((s9/usr/lib64/python2.7/distutils/command/install_headers.pytfinalize_optionss	cCsf|jj}|sdS|j|j�x9|D]1}|j||j�\}}|jj|�q-WdS(N(tdistributiontheaderstmkpathRt	copy_fileRtappend(RRtheadertoutt_((s9/usr/lib64/python2.7/distutils/command/install_headers.pytrun#s
cCs|jjpgS(N(R
R(R((s9/usr/lib64/python2.7/distutils/command/install_headers.pyt
get_inputs-scCs|jS(N(R(R((s9/usr/lib64/python2.7/distutils/command/install_headers.pytget_outputs0s(sinstall-dir=Rs$directory to install header files to(RRs-force installation (overwrite existing files)(
t__name__t
__module__tdescriptiontuser_optionstboolean_optionsR	RRRR(((s9/usr/lib64/python2.7/distutils/command/install_headers.pyRs					
	N(t__doc__t__revision__tdistutils.coreRR(((s9/usr/lib64/python2.7/distutils/command/install_headers.pyt<module>scommand/install_lib.pyc000064400000015031151702014350011171 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZeed�rcej	dZ
ndZ
d	efd
��YZdS(skdistutils.command.install_lib

Implements the Distutils 'install_lib' command
(install all Python modules).s$Id$i����N(tCommand(tDistutilsOptionErrortextseptpys.pytinstall_libc	Bs�eZdZddd d!d#d$d%gZdd
dgZid
d
6Zd�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd�ZRS(&s7install all Python modules (extensions and pure Python)sinstall-dir=tdsdirectory to install tos
build-dir=tbs'build directory (where to install from)tforcetfs-force installation (overwrite existing files)tcompiletcscompile .py to .pyc [default]s
no-compilesdon't compile .py filess	optimize=tOslalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0]s
skip-buildsskip the build stepscCs:d|_d|_d|_d|_d|_d|_dS(Ni(tNonetinstall_dirt	build_dirRR	toptimizet
skip_build(tself((s5/usr/lib64/python2.7/distutils/command/install_lib.pytinitialize_options7s					c	Cs�|jddddddd�|jdkr:d
|_n|jdkrUd|_nt|jt�s�y.t|j�|_|jdkr�t�nWq�ttfk
r�td
�q�XndS(Ntinstallt	build_libRRR
RR	RRiiisoptimize must be 0, 1, or 2(RR(RR
(RR(R	R	(RR(RR(iii(	tset_undefined_optionsR	RRt
isinstancetinttAssertionErrort
ValueErrorR(R((s5/usr/lib64/python2.7/distutils/command/install_lib.pytfinalize_options@s$	
cCsE|j�|j�}|dk	rA|jj�rA|j|�ndS(N(tbuildRRtdistributionthas_pure_modulestbyte_compile(Rtoutfiles((s5/usr/lib64/python2.7/distutils/command/install_lib.pytrunZs
cCsN|jsJ|jj�r(|jd�n|jj�rJ|jd�qJndS(Ntbuild_pyt	build_ext(RRRtrun_commandthas_ext_modules(R((s5/usr/lib64/python2.7/distutils/command/install_lib.pyRjs
	cCsLtjj|j�r0|j|j|j�}n|jd|j�dS|S(Ns3'%s' does not exist -- no Python modules to install(tostpathtisdirRt	copy_treeR
twarn(RR((s5/usr/lib64/python2.7/distutils/command/install_lib.pyRqs	cCs�tjr|jd�dSddlm}|jd�j}|jrp||ddd|jd|d	|j	�n|j
dkr�||d|j
d|jd|d
|jd	|j	�ndS(Ns%byte-compiling is disabled, skipping.i����(RRRiRtprefixtdry_runtverbose(tsystdont_write_bytecodeR)tdistutils.utilRtget_finalized_commandtrootR	RR+RR,(RtfilesRtinstall_root((s5/usr/lib64/python2.7/distutils/command/install_lib.pyRzs	
	
c
Cs�|s
gS|j|�}|j�}t||�}t|�ttj�}g}x.|D]&}	|jtjj||	|��qZW|S(N(	R0tget_outputstgetattrtlenR%tseptappendR&tjoin(
Rthas_anyt	build_cmdt
cmd_optiont
output_dirtbuild_filesRt
prefix_lentoutputstfile((s5/usr/lib64/python2.7/distutils/command/install_lib.pyt_mutate_outputs�s
$cCs�g}x�|D]z}tjjtjj|��d}|tkrGq
n|jrd|j|d�n|jdkr
|j|d�q
q
W|S(NiR
ito(R%R&tsplitexttnormcasetPYTHON_SOURCE_EXTENSIONR	R8R(Rtpy_filenamestbytecode_filestpy_filetext((s5/usr/lib64/python2.7/distutils/command/install_lib.pyt_bytecode_filenames�s
"	cCsu|j|jj�dd|j�}|jr?|j|�}ng}|j|jj�dd|j�}|||S(s�Return the list of files that would be installed if this command
        were actually run.  Not affected by the "dry-run" flag or whether
        modules have actually been built yet.
        R!RR"(RBRRR
R	RKR$(Rtpure_outputstbytecode_outputstext_outputs((s5/usr/lib64/python2.7/distutils/command/install_lib.pyR4�s	cCsrg}|jj�r:|jd�}|j|j��n|jj�rn|jd�}|j|j��n|S(s�Get the list of files that are input to this command, ie. the
        files that get installed as they are named in the build tree.
        The files in this list correspond one-to-one to the output
        filenames returned by 'get_outputs()'.
        R!R"(RRR0textendR4R$(RtinputsR!R"((s5/usr/lib64/python2.7/distutils/command/install_lib.pyt
get_inputs�s(sinstall-dir=Rsdirectory to install to(s
build-dir=Rs'build directory (where to install from)(RRs-force installation (overwrite existing files)(R	R
scompile .py to .pyc [default]N(s
no-compileNsdon't compile .py files(s	optimize=Rslalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0](s
skip-buildNsskip the build steps(t__name__t
__module__tdescriptionRtuser_optionstboolean_optionstnegative_optRRR RRRRBRKR4RQ(((s5/usr/lib64/python2.7/distutils/command/install_lib.pyRs*	
											(t__doc__t__revision__R%R-tdistutils.coreRtdistutils.errorsRthasattrRRFR(((s5/usr/lib64/python2.7/distutils/command/install_lib.pyt<module>scommand/install_scripts.pyc000064400000005560151702014350012120 0ustar00�
{fc@sbdZdZddlZddlmZddlmZddlmZdefd��YZ	dS(	sudistutils.command.install_scripts

Implements the Distutils 'install_scripts' command, for installing
Python scripts.s$Id$i����N(tCommand(tlog(tST_MODEtinstall_scriptscBsYeZdZddddgZdd
gZd�Zd
�Zd�Zd�Z	d�Z
RS(s%install scripts (Python or otherwise)sinstall-dir=tdsdirectory to install scripts tos
build-dir=tbs'build directory (where to install from)tforcetfs-force installation (overwrite existing files)s
skip-buildsskip the build stepscCs(d|_d|_d|_d|_dS(Ni(tNonetinstall_dirRt	build_dirt
skip_build(tself((s9/usr/lib64/python2.7/distutils/command/install_scripts.pytinitialize_optionss			cCs*|jdd	�|jdd
dd�dS(
Ntbuildt
build_scriptsR
tinstallRR	RR(RR
(RR	(RR(RR(tset_undefined_options(R((s9/usr/lib64/python2.7/distutils/command/install_scripts.pytfinalize_options#s
	cCs�|js|jd�n|j|j|j�|_tjdkr�xq|j�D]`}|j	rrt
jd|�qPtj|�t
dBd@}t
jd||�tj||�qPWndS(NRtposixschanging mode of %simi�schanging mode of %s to %o(Rtrun_commandt	copy_treeR
R	toutfilestostnametget_outputstdry_runRtinfotstatRtchmod(Rtfiletmode((s9/usr/lib64/python2.7/distutils/command/install_scripts.pytrun+s		cCs|jjpgS(N(tdistributiontscripts(R((s9/usr/lib64/python2.7/distutils/command/install_scripts.pyt
get_inputs:scCs
|jpgS(N(R(R((s9/usr/lib64/python2.7/distutils/command/install_scripts.pyR=s(sinstall-dir=Rsdirectory to install scripts to(s
build-dir=Rs'build directory (where to install from)(RRs-force installation (overwrite existing files)N(s
skip-buildNsskip the build steps(t__name__t
__module__tdescriptionRtuser_optionstboolean_optionsR
RR R#R(((s9/usr/lib64/python2.7/distutils/command/install_scripts.pyRs					(
t__doc__t__revision__Rtdistutils.coreRt	distutilsRRRR(((s9/usr/lib64/python2.7/distutils/command/install_scripts.pyt<module>scommand/sdist.pyc000064400000040470151702014350010030 0ustar00�
{fc@sdZdZddlZddlZddlZddlmZddlmZddlm	Z	ddl
mZmZm
Z
mZddlmZdd	lmZmZmZdd
lmZddl
mZddlmZd
�Zde	fd��YZdS(sadistutils.command.sdist

Implements the Distutils 'sdist' command (create a source distribution).s$Id$i����N(tglob(twarn(tCommand(tdir_utiltdep_utilt	file_utiltarchive_util(tTextFile(tDistutilsPlatformErrortDistutilsOptionErrortDistutilsTemplateError(tFileList(tlog(tconvert_pathcCs�ddlm}ddlm}g}x6|j�D](}|jd|d||df�q3W|j�||�jd�dS(soPrint all possible values for the 'formats' option (used by
    the "--help-formats" command-line option).
    i����(tFancyGetopt(tARCHIVE_FORMATSsformats=is.List of available source distribution formats:N(	tdistutils.fancy_getoptRtdistutils.archive_utilRtkeystappendtNonetsortt
print_help(RRtformatstformat((s//usr/lib64/python2.7/distutils/command/sdist.pytshow_formatss
tsdistcBs6eZdZd�Zd<d=d?d@dAdBdCdDdEddddfdFdGdHdIgZddddddgZd'd>d(efgZidd
6dd6Z	id)d*6d+d,6Z
d-efgZd.�Zd/�Z
d0�Zd1�Zd2�Zd3�Zd4�Zd5�Zd6�Zd7�Zd8�Zd9�Zd:�Zd;�ZRS(Js6create a source distribution (tarball, zip file, etc.)cCs|jS(sYCallable used for the check sub-command.

Placed here so user_options can view it(tmetadata_check(tself((s//usr/lib64/python2.7/distutils/command/sdist.pytchecking_metadata(ss	template=tts5name of manifest template file [default: MANIFEST.in]s	manifest=tms)name of manifest file [default: MANIFEST]suse-defaultssRinclude the default file set in the manifest [default; disable with --no-defaults]sno-defaultss"don't include the default file settprunes�specifically exclude files/directories that should not be distributed (build tree, RCS/CVS dirs, etc.) [default; disable with --no-prune]sno-prunes$don't automatically exclude anythings
manifest-onlytosEjust regenerate the manifest and then stop (implies --force-manifest)sforce-manifesttfskforcibly regenerate the manifest and carry on as usual. Deprecated: now the manifest is always regenerated.sformats=s6formats for source distribution (comma-separated list)s	keep-temptks1keep the distribution tree around after creating sarchive file(s)s	dist-dir=tdsFdirectory to put the source distribution archive(s) in [default: dist]smetadata-checks[Ensure that all required elements of meta-data are supplied. Warn if any missing. [default]sowner=tus@Owner name used when creating a tar file [default: current user]sgroup=tgsAGroup name used when creating a tar file [default: current group]shelp-formatss#list available distribution formatstgztartposixtziptnttcheckcCsyd|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_d|_d|_
dS(Nii(Rttemplatetmanifesttuse_defaultsR t
manifest_onlytforce_manifestRt	keep_temptdist_dirt
archive_filesRtownertgroup(R((s//usr/lib64/python2.7/distutils/command/sdist.pytinitialize_optionsfs												cCs�|jdkrd|_n|jdkr6d|_n|jd�|jdkr�y|jtjg|_Wq�tk
r�t	ddtj�q�Xnt
j|j�}|r�td|�n|j
dkr�d|_
ndS(NtMANIFESTsMANIFEST.inRs.don't know how to create source distributions son platform %ssunknown archive format '%s'tdist(R-RR,tensure_string_listRtdefault_formattostnametKeyErrorRRtcheck_archive_formatsR	R2(Rt
bad_format((s//usr/lib64/python2.7/distutils/command/sdist.pytfinalize_options}s$

cCsUt�|_x!|j�D]}|j|�qW|j�|jrGdS|j�dS(N(Rtfilelisttget_sub_commandstrun_commandt
get_file_listR/tmake_distribution(Rtcmd_name((s//usr/lib64/python2.7/distutils/command/sdist.pytrun�s
	cCs7tdt�|jjd�}|j�|j�dS(sDeprecated API.sadistutils.command.sdist.check_metadata is deprecated,               use the check command insteadR+N(RtPendingDeprecationWarningtdistributiontget_command_objtensure_finalizedRG(RR+((s//usr/lib64/python2.7/distutils/command/sdist.pytcheck_metadata�s

cCs�tjj|j�}|rP|j�rP|j�|jj�|jj�dS|sq|j	dd|j�n|jj
�|jr�|j�n|r�|j
�n|jr�|j�n|jj�|jj�|j�dS(sCFigure out the list of files to include in the source
        distribution, and put it in 'self.filelist'.  This might involve
        reading the manifest template (and writing the manifest), or just
        reading the manifest, or just using the default file set -- it all
        depends on the user's options.
        Ns&manifest template '%s' does not exist s(using default file list)(R;tpathtisfileR,t_manifest_is_not_generatedt
read_manifestRARtremove_duplicatesRtfindallR.tadd_defaultst
read_templateR tprune_file_listtwrite_manifest(Rttemplate_exists((s//usr/lib64/python2.7/distutils/command/sdist.pyRD�s(

cCsd|jjg}x�|D]�}t|t�r�|}d}x:|D]2}tjj|�rAd}|jj|�PqAqAW|s�|j	dt
j|d��q�qtjj|�r�|jj|�q|j	d|�qWdd	g}xB|D]:}ttjj
t|��}|r�|jj|�q�q�W|jd
�}|jj�rb|jj|j��nxM|jD]B\}	}
}}x-|D]%}
|jjtjj|
|
��q�WqlW|jj�rlx�|jjD]�}t|t�rt|�}tjj
|�re|jj|�qeq�|\}}x?|D]7}t|�}tjj
|�r*|jj|�q*q*Wq�Wn|jj�r�|jd�}|jj|j��n|jj�r�|jd�}|jj|j��n|jj�r|jd
�}|jj|j��ndS(s9Add all the default files to self.filelist:
          - README or README.txt
          - setup.py
          - test/test*.py
          - all pure Python modules mentioned in setup script
          - all files pointed by package_data (build_py)
          - all files defined in data_files.
          - all files defined as scripts.
          - all C sources listed as part of extensions or C libraries
            in the setup script (doesn't catch C headers!)
        Warns if (README or README.txt) or setup.py are missing; everything
        else is optional.
        tREADMEs
README.txtiis,standard file not found: should have one of s, sstandard file '%s' not founds
test/test*.pys	setup.cfgtbuild_pyt	build_extt
build_clibt
build_scriptsN(RXs
README.txt(RItscript_namet
isinstancettupleR;RMtexistsRARRtstringtjointfilterRNRtextendtget_finalized_commandthas_pure_modulestget_source_filest
data_filesthas_data_fileststrR
thas_ext_modulesthas_c_librariesthas_scripts(Rt	standardstfntaltstgot_ittoptionaltpatterntfilesRYtpkgtsrc_dirt	build_dirt	filenamestfilenametitemtdirnameR"RZR[R\((s//usr/lib64/python2.7/distutils/command/sdist.pyRS�s^

'
cCs�tjd|j�t|jdddddddddddd�}zwxp|j�}|d
krhPny|jj|�WqLtt	fk
r�}|j
d	|j|j|f�qLXqLWWd
|j
�Xd
S(s�Read and parse manifest template file named by self.template.

(usually "MANIFEST.in") The parsing and processing is done by
        'self.filelist', which updates itself accordingly.
        sreading manifest template '%s'tstrip_commentsitskip_blankst
join_linest	lstrip_wst	rstrip_wst
collapse_joins%s, line %d: %sN(RtinfoR,RtreadlineRRAtprocess_template_lineR
t
ValueErrorRRytcurrent_linetclose(RR,tlinetmsg((s//usr/lib64/python2.7/distutils/command/sdist.pyRT,s(	cCs�|jd�}|jj�}|jjdd|j�|jjdd|�tjdkred}nd}dddd	d
ddg}d
|dj	|�|f}|jj|dd�dS(svPrune off branches that might slip into the file list as created
        by 'read_template()', but really don't belong there:
          * the build tree (typically "build")
          * the release tree itself (only an issue if we ran "sdist"
            previously with --keep-temp, or it aborted)
          * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
        tbuildtprefixtwin32s/|\\t/tRCStCVSs\.svns\.hgs\.gits\.bzrt_darcss(^|%s)(%s)(%s).*t|tis_regexiN(
ReRItget_fullnameRAtexclude_patternRt
build_basetsystplatformRb(RR�tbase_dirtsepstvcs_dirstvcs_ptrn((s//usr/lib64/python2.7/distutils/command/sdist.pyRUMs		cCsk|j�r$tjd|j�dS|jj}|jdd�|jtj	|j|fd|j�dS(s�Write the file list in 'self.filelist' (presumably as filled in
        by 'add_defaults()' and 'read_template()') to the manifest file
        named by 'self.manifest'.
        s5not writing to manually maintained manifest file '%s'Nis*# file GENERATED by distutils, do NOT editswriting manifest file '%s'(
RORR�R-RARttinserttexecuteRt
write_file(Rtcontent((s//usr/lib64/python2.7/distutils/command/sdist.pyRVgs	
cCsStjj|j�stSt|jd�}z|j�}Wd|j�X|dkS(NtrUs+# file GENERATED by distutils, do NOT edit
(R;RMRNR-tFalsetopenR�R�(Rtfpt
first_line((s//usr/lib64/python2.7/distutils/command/sdist.pyROvscCsytjd|j�t|j�}xF|D]>}|j�}|jd�s)|rWq)n|jj|�q)W|j�dS(s�Read the manifest file (named by 'self.manifest') and use it to
        fill in 'self.filelist', the list of files to include in the source
        distribution.
        sreading manifest file '%s't#N(	RR�R-R�tstript
startswithRARR�(RR-R�((s//usr/lib64/python2.7/distutils/command/sdist.pyRP�s
cCs�|j|�tj||d|j�ttd�rHd}d|}nd}d|}|sntjd�n
tj	|�x_|D]W}tj
j|�s�tjd|�q�tj
j||�}|j
||d|�q�W|jjj|�dS(	s�Create the directory tree that will become the source
        distribution archive.  All directories implied by the filenames in
        'files' are created under 'base_dir', and then we hard link or copy
        (if hard linking is unavailable) those files into place.
        Essentially, this duplicates the developer's source tree, but in a
        directory named after the distribution, containing only the files
        to be distributed.
        tdry_runtlinkthardsmaking hard links in %s...scopying files to %s...s)no files to distribute -- empty manifest?s#'%s' not a regular file -- skippingN(tmkpathRtcreate_treeR�thasattrR;RRRR�RMRNRbt	copy_fileRItmetadatatwrite_pkg_info(RR�RtR�R�tfiletdest((s//usr/lib64/python2.7/distutils/command/sdist.pytmake_release_tree�s

c
Cs|jj�}tjj|j|�}|j||jj�g}d|j	kr}|j	j
|j	j|j	jd���nxd|j	D]Y}|j
||d|d|jd|j�}|j
|�|jjj
dd|f�q�W||_|jstj|d|j�ndS(	s�Create the source distribution(s).  First, we create the release
        tree with 'make_release_tree()'; then, we create all required
        archive files (according to 'self.formats') from the release tree.
        Finally, we clean up by blowing away the release tree (unless
        'self.keep_temp' is true).  The list of archive files created is
        stored so it can be retrieved later by 'get_archive_files()'.
        ttarR�R4R5RtR�N(RIR�R;RMRbR2R�RARtRRtpoptindextmake_archiveR4R5t
dist_filesR3R1Rtremove_treeR�(RR�t	base_nameR3tfmtR�((s//usr/lib64/python2.7/distutils/command/sdist.pyRE�s
+
 		cCs|jS(szReturn the list of archive files created when the command
        was run, or None if the command hasn't run yet.
        (R3(R((s//usr/lib64/python2.7/distutils/command/sdist.pytget_archive_files�s(s	template=Rs5name of manifest template file [default: MANIFEST.in](s	manifest=Rs)name of manifest file [default: MANIFEST]N(suse-defaultsNsRinclude the default file set in the manifest [default; disable with --no-defaults](sno-defaultsNs"don't include the default file set(R Ns�specifically exclude files/directories that should not be distributed (build tree, RCS/CVS dirs, etc.) [default; disable with --no-prune](sno-pruneNs$don't automatically exclude anything(s
manifest-onlyR!sEjust regenerate the manifest and then stop (implies --force-manifest)(sforce-manifestR"skforcibly regenerate the manifest and carry on as usual. Deprecated: now the manifest is always regenerated.(sformats=Ns6formats for source distribution (comma-separated list)(s	dist-dir=R$sFdirectory to put the source distribution archive(s) in [default: dist](smetadata-checkNs[Ensure that all required elements of meta-data are supplied. Warn if any missing. [default](sowner=R%s@Owner name used when creating a tar file [default: current user](sgroup=R&sAGroup name used when creating a tar file [default: current group](t__name__t
__module__tdescriptionRRtuser_optionstboolean_optionsRthelp_optionstnegative_optR:tsub_commandsR6R@RGRLRDRSRTRURVRORPR�RER�(((s//usr/lib64/python2.7/distutils/command/sdist.pyR$sn

(	R	!					*	(t__doc__t__revision__R;RaR�RtwarningsRtdistutils.coreRt	distutilsRRRRtdistutils.text_fileRtdistutils.errorsRR	R
tdistutils.filelistRRtdistutils.utilR
RR(((s//usr/lib64/python2.7/distutils/command/sdist.pyt<module>s"	command/build_ext.py000064400000077377151702014350010536 0ustar00"""distutils.command.build_ext

Implements the Distutils 'build_ext' command, for building extension
modules (currently limited to C extensions, should accommodate C++
extensions ASAP)."""

# This module should be kept compatible with Python 2.1.

__revision__ = "$Id$"

import sys, os, string, re
from types import *
from site import USER_BASE, USER_SITE
from distutils.core import Command
from distutils.errors import *
from distutils.sysconfig import customize_compiler, get_python_version
from distutils.dep_util import newer_group
from distutils.extension import Extension
from distutils.util import get_platform
from distutils import log

if os.name == 'nt':
    from distutils.msvccompiler import get_build_version
    MSVC_VERSION = int(get_build_version())

# An extension name is just a dot-separated list of Python NAMEs (ie.
# the same as a fully-qualified module name).
extension_name_re = re.compile \
    (r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$')

def show_compilers ():
    from distutils.ccompiler import show_compilers
    show_compilers()

class build_ext (Command):

description = "build C/C++ extensions (compile/link to build directory)"

# XXX thoughts on how to deal with complex command-line options like
    # these, i.e. how to make it so fancy_getopt can suck them off the
    # command line and make it look like setup.py defined the appropriate
    # lists of tuples of what-have-you.
    #   - each command needs a callback to process its command-line options
    #   - Command.__init__() needs access to its share of the whole
    #     command line (must ultimately come from
    #     Distribution.parse_command_line())
    #   - it then calls the current command class' option-parsing
    #     callback to deal with weird options like -D, which have to
    #     parse the option text and churn out some custom data
    #     structure
    #   - that data structure (in this case, a list of 2-tuples)
    #     will then be present in the command object by the time
    #     we get to finalize_options() (i.e. the constructor
    #     takes care of both command-line and client options
    #     in between initialize_options() and finalize_options())

sep_by = " (separated by '%s')" % os.pathsep
    user_options = [
        ('build-lib=', 'b',
         "directory for compiled extension modules"),
        ('build-temp=', 't',
         "directory for temporary files (build by-products)"),
        ('plat-name=', 'p',
         "platform name to cross-compile for, if supported "
         "(default: %s)" % get_platform()),
        ('inplace', 'i',
         "ignore build-lib and put compiled extensions into the source " +
         "directory alongside your pure Python modules"),
        ('include-dirs=', 'I',
         "list of directories to search for header files" + sep_by),
        ('define=', 'D',
         "C preprocessor macros to define"),
        ('undef=', 'U',
         "C preprocessor macros to undefine"),
        ('libraries=', 'l',
         "external C libraries to link with"),
        ('library-dirs=', 'L',
         "directories to search for external C libraries" + sep_by),
        ('rpath=', 'R',
         "directories to search for shared C libraries at runtime"),
        ('link-objects=', 'O',
         "extra explicit link objects to include in the link"),
        ('debug', 'g',
         "compile/link with debugging information"),
        ('force', 'f',
         "forcibly build everything (ignore file timestamps)"),
        ('compiler=', 'c',
         "specify the compiler type"),
        ('swig-cpp', None,
         "make SWIG create C++ files (default is C)"),
        ('swig-opts=', None,
         "list of SWIG command line options"),
        ('swig=', None,
         "path to the SWIG executable"),
        ('user', None,
         "add user include, library and rpath"),
        ]

boolean_options = ['inplace', 'debug', 'force', 'swig-cpp', 'user']

help_options = [
        ('help-compiler', None,
         "list available compilers", show_compilers),
        ]

def initialize_options (self):
        self.extensions = None
        self.build_lib = None
        self.plat_name = None
        self.build_temp = None
        self.inplace = 0
        self.package = None

self.include_dirs = None
        self.define = None
        self.undef = None
        self.libraries = None
        self.library_dirs = None
        self.rpath = None
        self.link_objects = None
        self.debug = None
        self.force = None
        self.compiler = None
        self.swig = None
        self.swig_cpp = None
        self.swig_opts = None
        self.user = None

def finalize_options(self):
        from distutils import sysconfig

self.set_undefined_options('build',
                                   ('build_lib', 'build_lib'),
                                   ('build_temp', 'build_temp'),
                                   ('compiler', 'compiler'),
                                   ('debug', 'debug'),
                                   ('force', 'force'),
                                   ('plat_name', 'plat_name'),
                                   )

if self.package is None:
            self.package = self.distribution.ext_package

self.extensions = self.distribution.ext_modules

# Make sure Python's include directories (for Python.h, pyconfig.h,
        # etc.) are in the include search path.
        py_include = sysconfig.get_python_inc()
        plat_py_include = sysconfig.get_python_inc(plat_specific=1)
        if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        if isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

# Put the Python "system" include dir at the end, so that
        # any local include dirs take precedence.
        self.include_dirs.append(py_include)
        if plat_py_include != py_include:
            self.include_dirs.append(plat_py_include)

self.ensure_string_list('libraries')
        self.ensure_string_list('link_objects')

# Life is easier if we're not forever checking for None, so
        # simplify these options to empty lists if unset
        if self.libraries is None:
            self.libraries = []
        if self.library_dirs is None:
            self.library_dirs = []
        elif type(self.library_dirs) is StringType:
            self.library_dirs = string.split(self.library_dirs, os.pathsep)

if self.rpath is None:
            self.rpath = []
        elif type(self.rpath) is StringType:
            self.rpath = string.split(self.rpath, os.pathsep)

# for extensions under windows use different directories
        # for Release and Debug builds.
        # also Python's library directory must be appended to library_dirs
        if os.name == 'nt':
            # the 'libs' directory is for binary installs - we assume that
            # must be the *native* platform.  But we don't really support
            # cross-compiling via a binary install anyway, so we let it go.
            self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
            if self.debug:
                self.build_temp = os.path.join(self.build_temp, "Debug")
            else:
                self.build_temp = os.path.join(self.build_temp, "Release")

# Append the source distribution include and library directories,
            # this allows distutils on windows to work in the source tree
            self.include_dirs.append(os.path.join(sys.exec_prefix, 'PC'))
            if MSVC_VERSION == 9:
                # Use the .lib files for the correct architecture
                if self.plat_name == 'win32':
                    suffix = ''
                else:
                    # win-amd64 or win-ia64
                    suffix = self.plat_name[4:]
                # We could have been built in one of two places; add both
                for d in ('PCbuild',), ('PC', 'VS9.0'):
                    new_lib = os.path.join(sys.exec_prefix, *d)
                    if suffix:
                        new_lib = os.path.join(new_lib, suffix)
                    self.library_dirs.append(new_lib)

elif MSVC_VERSION == 8:
                self.library_dirs.append(os.path.join(sys.exec_prefix,
                                         'PC', 'VS8.0'))
            elif MSVC_VERSION == 7:
                self.library_dirs.append(os.path.join(sys.exec_prefix,
                                         'PC', 'VS7.1'))
            else:
                self.library_dirs.append(os.path.join(sys.exec_prefix,
                                         'PC', 'VC6'))

# OS/2 (EMX) doesn't support Debug vs Release builds, but has the
        # import libraries in its "Config" subdirectory
        if os.name == 'os2':
            self.library_dirs.append(os.path.join(sys.exec_prefix, 'Config'))

# for extensions under Cygwin and AtheOS Python's library directory must be
        # appended to library_dirs
        if sys.platform[:6] == 'cygwin' or sys.platform[:6] == 'atheos':
            if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
                # building third party extensions
                self.library_dirs.append(os.path.join(sys.prefix, "lib",
                                                      "python" + get_python_version(),
                                                      "config"))
            else:
                # building python standard extensions
                self.library_dirs.append('.')

# For building extensions with a shared Python library,
        # Python's library directory must be appended to library_dirs
        # See Issues: #1600860, #4366
        if (sysconfig.get_config_var('Py_ENABLE_SHARED')):
            if not sysconfig.python_build:
                # building third party extensions
                self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
            else:
                # building python standard extensions
                self.library_dirs.append('.')

# The argument parsing will result in self.define being a string, but
        # it has to be a list of 2-tuples.  All the preprocessor symbols
        # specified by the 'define' option will be set to '1'.  Multiple
        # symbols can be separated with commas.

if self.define:
            defines = self.define.split(',')
            self.define = map(lambda symbol: (symbol, '1'), defines)

# The option for macros to undefine is also a string from the
        # option parsing, but has to be a list.  Multiple symbols can also
        # be separated with commas here.
        if self.undef:
            self.undef = self.undef.split(',')

if self.swig_opts is None:
            self.swig_opts = []
        else:
            self.swig_opts = self.swig_opts.split(' ')

# Finally add the user include and library directories if requested
        if self.user:
            user_include = os.path.join(USER_BASE, "include")
            user_lib = os.path.join(USER_BASE, "lib")
            if os.path.isdir(user_include):
                self.include_dirs.append(user_include)
            if os.path.isdir(user_lib):
                self.library_dirs.append(user_lib)
                self.rpath.append(user_lib)

def run(self):
        from distutils.ccompiler import new_compiler

# 'self.extensions', as supplied by setup.py, is a list of
        # Extension instances.  See the documentation for Extension (in
        # distutils.extension) for details.
        #
        # For backwards compatibility with Distutils 0.8.2 and earlier, we
        # also allow the 'extensions' list to be a list of tuples:
        #    (ext_name, build_info)
        # where build_info is a dictionary containing everything that
        # Extension instances do except the name, with a few things being
        # differently named.  We convert these 2-tuples to Extension
        # instances as needed.

if not self.extensions:
            return

# If we were asked to build any C/C++ libraries, make sure that the
        # directory where we put them is in the library search path for
        # linking extensions.
        if self.distribution.has_c_libraries():
            build_clib = self.get_finalized_command('build_clib')
            self.libraries.extend(build_clib.get_library_names() or [])
            self.library_dirs.append(build_clib.build_clib)

# Setup the CCompiler object that we'll use to do all the
        # compiling and linking
        self.compiler = new_compiler(compiler=self.compiler,
                                     verbose=self.verbose,
                                     dry_run=self.dry_run,
                                     force=self.force)
        customize_compiler(self.compiler)
        # If we are cross-compiling, init the compiler now (if we are not
        # cross-compiling, init would not hurt, but people may rely on
        # late initialization of compiler even if they shouldn't...)
        if os.name == 'nt' and self.plat_name != get_platform():
            self.compiler.initialize(self.plat_name)

# And make sure that any compile/link-related options (which might
        # come from the command-line or from the setup script) are set in
        # that CCompiler object -- that way, they automatically apply to
        # all compiling and linking done here.
        if self.include_dirs is not None:
            self.compiler.set_include_dirs(self.include_dirs)
        if self.define is not None:
            # 'define' option is a list of (name,value) tuples
            for (name, value) in self.define:
                self.compiler.define_macro(name, value)
        if self.undef is not None:
            for macro in self.undef:
                self.compiler.undefine_macro(macro)
        if self.libraries is not None:
            self.compiler.set_libraries(self.libraries)
        if self.library_dirs is not None:
            self.compiler.set_library_dirs(self.library_dirs)
        if self.rpath is not None:
            self.compiler.set_runtime_library_dirs(self.rpath)
        if self.link_objects is not None:
            self.compiler.set_link_objects(self.link_objects)

# Now actually compile and link everything.
        self.build_extensions()

def check_extensions_list(self, extensions):
        """Ensure that the list of extensions (presumably provided as a
        command option 'extensions') is valid, i.e. it is a list of
        Extension objects.  We also support the old-style list of 2-tuples,
        where the tuples are (ext_name, build_info), which are converted to
        Extension instances here.

Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        """
        if not isinstance(extensions, list):
            raise DistutilsSetupError, \
                  "'ext_modules' option must be a list of Extension instances"

for i, ext in enumerate(extensions):
            if isinstance(ext, Extension):
                continue                # OK! (assume type-checking done
                                        # by Extension constructor)

if not isinstance(ext, tuple) or len(ext) != 2:
                raise DistutilsSetupError, \
                      ("each element of 'ext_modules' option must be an "
                       "Extension instance or 2-tuple")

ext_name, build_info = ext

log.warn(("old-style (ext_name, build_info) tuple found in "
                      "ext_modules for extension '%s' "
                      "-- please convert to Extension instance" % ext_name))

if not (isinstance(ext_name, str) and
                    extension_name_re.match(ext_name)):
                raise DistutilsSetupError, \
                      ("first element of each tuple in 'ext_modules' "
                       "must be the extension name (a string)")

if not isinstance(build_info, dict):
                raise DistutilsSetupError, \
                      ("second element of each tuple in 'ext_modules' "
                       "must be a dictionary (build info)")

# OK, the (ext_name, build_info) dict is type-safe: convert it
            # to an Extension instance.
            ext = Extension(ext_name, build_info['sources'])

# Easy stuff: one-to-one mapping from dict elements to
            # instance attributes.
            for key in ('include_dirs', 'library_dirs', 'libraries',
                        'extra_objects', 'extra_compile_args',
                        'extra_link_args'):
                val = build_info.get(key)
                if val is not None:
                    setattr(ext, key, val)

# Medium-easy stuff: same syntax/semantics, different names.
            ext.runtime_library_dirs = build_info.get('rpath')
            if 'def_file' in build_info:
                log.warn("'def_file' element of build info dict "
                         "no longer supported")

# Non-trivial stuff: 'macros' split into 'define_macros'
            # and 'undef_macros'.
            macros = build_info.get('macros')
            if macros:
                ext.define_macros = []
                ext.undef_macros = []
                for macro in macros:
                    if not (isinstance(macro, tuple) and len(macro) in (1, 2)):
                        raise DistutilsSetupError, \
                              ("'macros' element of build info dict "
                               "must be 1- or 2-tuple")
                    if len(macro) == 1:
                        ext.undef_macros.append(macro[0])
                    elif len(macro) == 2:
                        ext.define_macros.append(macro)

extensions[i] = ext

def get_source_files(self):
        self.check_extensions_list(self.extensions)
        filenames = []

# Wouldn't it be neat if we knew the names of header files too...
        for ext in self.extensions:
            filenames.extend(ext.sources)

return filenames

def get_outputs(self):
        # Sanity check the 'extensions' list -- can't assume this is being
        # done in the same run as a 'build_extensions()' call (in fact, we
        # can probably assume that it *isn't*!).
        self.check_extensions_list(self.extensions)

# And build the list of output (built) filenames.  Note that this
        # ignores the 'inplace' flag, and assumes everything goes in the
        # "build" tree.
        outputs = []
        for ext in self.extensions:
            outputs.append(self.get_ext_fullpath(ext.name))
        return outputs

def build_extensions(self):
        # First, sanity-check the 'extensions' list
        self.check_extensions_list(self.extensions)

for ext in self.extensions:
            self.build_extension(ext)

def build_extension(self, ext):
        sources = ext.sources
        if sources is None or type(sources) not in (ListType, TupleType):
            raise DistutilsSetupError, \
                  ("in 'ext_modules' option (extension '%s'), " +
                   "'sources' must be present and must be " +
                   "a list of source filenames") % ext.name
        sources = list(sources)

ext_path = self.get_ext_fullpath(ext.name)
        depends = sources + ext.depends
        if not (self.force or newer_group(depends, ext_path, 'newer')):
            log.debug("skipping '%s' extension (up-to-date)", ext.name)
            return
        else:
            log.info("building '%s' extension", ext.name)

# First, scan the sources for SWIG definition files (.i), run
        # SWIG on 'em to create .c files, and modify the sources list
        # accordingly.
        sources = self.swig_sources(sources, ext)

# Next, compile the source code to object files.

# XXX not honouring 'define_macros' or 'undef_macros' -- the
        # CCompiler API needs to change to accommodate this, and I
        # want to do one thing at a time!

# Two possible sources for extra compiler arguments:
        #   - 'extra_compile_args' in Extension object
        #   - CFLAGS environment variable (not particularly
        #     elegant, but people seem to expect it and I
        #     guess it's useful)
        # The environment variable should take precedence, and
        # any sensible compiler will give precedence to later
        # command line args.  Hence we combine them in order:
        extra_args = ext.extra_compile_args or []

macros = ext.define_macros[:]
        for undef in ext.undef_macros:
            macros.append((undef,))

objects = self.compiler.compile(sources,
                                         output_dir=self.build_temp,
                                         macros=macros,
                                         include_dirs=ext.include_dirs,
                                         debug=self.debug,
                                         extra_postargs=extra_args,
                                         depends=ext.depends)

# XXX -- this is a Vile HACK!
        #
        # The setup.py script for Python on Unix needs to be able to
        # get this list so it can perform all the clean up needed to
        # avoid keeping object files around when cleaning out a failed
        # build of an extension module.  Since Distutils does not
        # track dependencies, we have to get rid of intermediates to
        # ensure all the intermediates will be properly re-built.
        #
        self._built_objects = objects[:]

# Now link the object files together into a "shared object" --
        # of course, first we have to figure out all the other things
        # that go into the mix.
        if ext.extra_objects:
            objects.extend(ext.extra_objects)
        extra_args = ext.extra_link_args or []

# Detect target language, if not provided
        language = ext.language or self.compiler.detect_language(sources)

self.compiler.link_shared_object(
            objects, ext_path,
            libraries=self.get_libraries(ext),
            library_dirs=ext.library_dirs,
            runtime_library_dirs=ext.runtime_library_dirs,
            extra_postargs=extra_args,
            export_symbols=self.get_export_symbols(ext),
            debug=self.debug,
            build_temp=self.build_temp,
            target_lang=language)

def swig_sources (self, sources, extension):

"""Walk the list of source files in 'sources', looking for SWIG
        interface (.i) files.  Run SWIG on all that are found, and
        return a modified 'sources' list with SWIG source files replaced
        by the generated C (or C++) files.
        """

new_sources = []
        swig_sources = []
        swig_targets = {}

# XXX this drops generated C/C++ files into the source tree, which
        # is fine for developers who want to distribute the generated
        # source -- but there should be an option to put SWIG output in
        # the temp dir.

if self.swig_cpp:
            log.warn("--swig-cpp is deprecated - use --swig-opts=-c++")

if self.swig_cpp or ('-c++' in self.swig_opts) or \
           ('-c++' in extension.swig_opts):
            target_ext = '.cpp'
        else:
            target_ext = '.c'

for source in sources:
            (base, ext) = os.path.splitext(source)
            if ext == ".i":             # SWIG interface file
                new_sources.append(base + '_wrap' + target_ext)
                swig_sources.append(source)
                swig_targets[source] = new_sources[-1]
            else:
                new_sources.append(source)

if not swig_sources:
            return new_sources

swig = self.swig or self.find_swig()
        swig_cmd = [swig, "-python"]
        swig_cmd.extend(self.swig_opts)
        if self.swig_cpp:
            swig_cmd.append("-c++")

# Do not override commandline arguments
        if not self.swig_opts:
            for o in extension.swig_opts:
                swig_cmd.append(o)

for source in swig_sources:
            target = swig_targets[source]
            log.info("swigging %s to %s", source, target)
            self.spawn(swig_cmd + ["-o", target, source])

return new_sources

# swig_sources ()

def find_swig (self):
        """Return the name of the SWIG executable.  On Unix, this is
        just "swig" -- it should be in the PATH.  Tries a bit harder on
        Windows.
        """

if os.name == "posix":
            return "swig"
        elif os.name == "nt":

# Look for SWIG in its standard installation directory on
            # Windows (or so I presume!).  If we find it there, great;
            # if not, act like Unix and assume it's in the PATH.
            for vers in ("1.3", "1.2", "1.1"):
                fn = os.path.join("c:\\swig%s" % vers, "swig.exe")
                if os.path.isfile(fn):
                    return fn
            else:
                return "swig.exe"

elif os.name == "os2":
            # assume swig available in the PATH.
            return "swig.exe"

else:
            raise DistutilsPlatformError, \
                  ("I don't know how to find (much less run) SWIG "
                   "on platform '%s'") % os.name

# find_swig ()

# -- Name generators -----------------------------------------------
    # (extension names, filenames, whatever)
    def get_ext_fullpath(self, ext_name):
        """Returns the path of the filename for a given extension.

The file is located in `build_lib` or directly in the package
        (inplace option).
        """
        # makes sure the extension name is only using dots
        all_dots = string.maketrans('/'+os.sep, '..')
        ext_name = ext_name.translate(all_dots)

fullname = self.get_ext_fullname(ext_name)
        modpath = fullname.split('.')
        filename = self.get_ext_filename(ext_name)
        filename = os.path.split(filename)[-1]

if not self.inplace:
            # no further work needed
            # returning :
            #   build_dir/package/path/filename
            filename = os.path.join(*modpath[:-1]+[filename])
            return os.path.join(self.build_lib, filename)

# the inplace option requires to find the package directory
        # using the build_py command for that
        package = '.'.join(modpath[0:-1])
        build_py = self.get_finalized_command('build_py')
        package_dir = os.path.abspath(build_py.get_package_dir(package))

# returning
        #   package_dir/filename
        return os.path.join(package_dir, filename)

def get_ext_fullname(self, ext_name):
        """Returns the fullname of a given extension name.

Adds the `package.` prefix"""
        if self.package is None:
            return ext_name
        else:
            return self.package + '.' + ext_name

def get_ext_filename(self, ext_name):
        r"""Convert the name of an extension (eg. "foo.bar") into the name
        of the file from which it will be loaded (eg. "foo/bar.so", or
        "foo\bar.pyd").
        """
        from distutils.sysconfig import get_config_var
        ext_path = string.split(ext_name, '.')
        # OS/2 has an 8 character module (extension) limit :-(
        if os.name == "os2":
            ext_path[len(ext_path) - 1] = ext_path[len(ext_path) - 1][:8]
        # extensions in debug_mode are named 'module_d.pyd' under windows
        so_ext = get_config_var('SO')
        if os.name == 'nt' and self.debug:
            return os.path.join(*ext_path) + '_d' + so_ext
        
        # Similarly, extensions in debug mode are named 'module_d.so', to
        # avoid adding the _d to the SO config variable:
        return os.path.join(*ext_path) + (sys.pydebug and "_d" or "") + so_ext

def get_export_symbols (self, ext):
        """Return the list of symbols that a shared extension has to
        export.  This either uses 'ext.export_symbols' or, if it's not
        provided, "init" + module_name.  Only relevant on Windows, where
        the .pyd file (DLL) must export the module "init" function.
        """
        initfunc_name = "init" + ext.name.split('.')[-1]
        if initfunc_name not in ext.export_symbols:
            ext.export_symbols.append(initfunc_name)
        return ext.export_symbols

def get_libraries (self, ext):
        """Return the list of libraries to link against when building a
        shared extension.  On most platforms, this is just 'ext.libraries';
        on Windows and OS/2, we add the Python library (eg. python20.dll).
        """
        # The python library is always needed on Windows.  For MSVC, this
        # is redundant, since the library is mentioned in a pragma in
        # pyconfig.h that MSVC groks.  The other Windows compilers all seem
        # to need it mentioned explicitly, though, so that's what we do.
        # Append '_d' to the python import library on debug builds.
        if sys.platform == "win32":
            from distutils.msvccompiler import MSVCCompiler
            if not isinstance(self.compiler, MSVCCompiler):
                template = "python%d%d"
                if self.debug:
                    template = template + '_d'
                pythonlib = (template %
                       (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
                # don't extend ext.libraries, it may be shared with other
                # extensions, it is a reference to the original list
                return ext.libraries + [pythonlib]
            else:
                return ext.libraries
        elif sys.platform == "os2emx":
            # EMX/GCC requires the python library explicitly, and I
            # believe VACPP does as well (though not confirmed) - AIM Apr01
            template = "python%d%d"
            # debug versions of the main DLL aren't supported, at least
            # not at this time - AIM Apr01
            #if self.debug:
            #    template = template + '_d'
            pythonlib = (template %
                   (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
            # don't extend ext.libraries, it may be shared with other
            # extensions, it is a reference to the original list
            return ext.libraries + [pythonlib]
        elif sys.platform[:6] == "cygwin":
            template = "python%d.%d"
            pythonlib = (template %
                   (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
            # don't extend ext.libraries, it may be shared with other
            # extensions, it is a reference to the original list
            return ext.libraries + [pythonlib]
        elif sys.platform[:6] == "atheos":
            from distutils import sysconfig

template = "python%d.%d"
            pythonlib = (template %
                   (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
            # Get SHLIBS from Makefile
            extra = []
            for lib in sysconfig.get_config_var('SHLIBS').split():
                if lib.startswith('-l'):
                    extra.append(lib[2:])
                else:
                    extra.append(lib)
            # don't extend ext.libraries, it may be shared with other
            # extensions, it is a reference to the original list
            return ext.libraries + [pythonlib, "m"] + extra

elif sys.platform == 'darwin':
            # Don't use the default code below
            return ext.libraries
        elif sys.platform[:3] == 'aix':
            # Don't use the default code below
            return ext.libraries
        else:
            from distutils import sysconfig
            if sysconfig.get_config_var('Py_ENABLE_SHARED'):
                template = "python%d.%d"
                pythonlib = (template %
                             (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
                if sys.pydebug:
                    pythonlib += '_d'
                return ext.libraries + [pythonlib]
            else:
                return ext.libraries

# class build_ext
command/build_ext.py.debug-build000064400000077016151702014350012706 0ustar00"""distutils.command.build_ext

Implements the Distutils 'build_ext' command, for building extension
modules (currently limited to C extensions, should accommodate C++
extensions ASAP)."""

# This module should be kept compatible with Python 2.1.

__revision__ = "$Id$"

if os.name == 'nt':
    from distutils.msvccompiler import get_build_version
    MSVC_VERSION = int(get_build_version())

def show_compilers ():
    from distutils.ccompiler import show_compilers
    show_compilers()

class build_ext (Command):

description = "build C/C++ extensions (compile/link to build directory)"

boolean_options = ['inplace', 'debug', 'force', 'swig-cpp', 'user']

help_options = [
        ('help-compiler', None,
         "list available compilers", show_compilers),
        ]

def finalize_options(self):
        from distutils import sysconfig

if self.package is None:
            self.package = self.distribution.ext_package

self.extensions = self.distribution.ext_modules

self.ensure_string_list('libraries')
        self.ensure_string_list('link_objects')

if self.rpath is None:
            self.rpath = []
        elif type(self.rpath) is StringType:
            self.rpath = string.split(self.rpath, os.pathsep)

if self.define:
            defines = self.define.split(',')
            self.define = map(lambda symbol: (symbol, '1'), defines)

if self.swig_opts is None:
            self.swig_opts = []
        else:
            self.swig_opts = self.swig_opts.split(' ')

def run(self):
        from distutils.ccompiler import new_compiler

if not self.extensions:
            return

# Now actually compile and link everything.
        self.build_extensions()

ext_name, build_info = ext

log.warn(("old-style (ext_name, build_info) tuple found in "
                      "ext_modules for extension '%s' "
                      "-- please convert to Extension instance" % ext_name))

# OK, the (ext_name, build_info) dict is type-safe: convert it
            # to an Extension instance.
            ext = Extension(ext_name, build_info['sources'])

extensions[i] = ext

def get_source_files(self):
        self.check_extensions_list(self.extensions)
        filenames = []

# Wouldn't it be neat if we knew the names of header files too...
        for ext in self.extensions:
            filenames.extend(ext.sources)

return filenames

def build_extensions(self):
        # First, sanity-check the 'extensions' list
        self.check_extensions_list(self.extensions)

for ext in self.extensions:
            self.build_extension(ext)

# Next, compile the source code to object files.

# XXX not honouring 'define_macros' or 'undef_macros' -- the
        # CCompiler API needs to change to accommodate this, and I
        # want to do one thing at a time!

macros = ext.define_macros[:]
        for undef in ext.undef_macros:
            macros.append((undef,))

# Detect target language, if not provided
        language = ext.language or self.compiler.detect_language(sources)

def swig_sources (self, sources, extension):

new_sources = []
        swig_sources = []
        swig_targets = {}

if self.swig_cpp:
            log.warn("--swig-cpp is deprecated - use --swig-opts=-c++")

if self.swig_cpp or ('-c++' in self.swig_opts) or \
           ('-c++' in extension.swig_opts):
            target_ext = '.cpp'
        else:
            target_ext = '.c'

if not swig_sources:
            return new_sources

swig = self.swig or self.find_swig()
        swig_cmd = [swig, "-python"]
        swig_cmd.extend(self.swig_opts)
        if self.swig_cpp:
            swig_cmd.append("-c++")

# Do not override commandline arguments
        if not self.swig_opts:
            for o in extension.swig_opts:
                swig_cmd.append(o)

for source in swig_sources:
            target = swig_targets[source]
            log.info("swigging %s to %s", source, target)
            self.spawn(swig_cmd + ["-o", target, source])

return new_sources

# swig_sources ()

def find_swig (self):
        """Return the name of the SWIG executable.  On Unix, this is
        just "swig" -- it should be in the PATH.  Tries a bit harder on
        Windows.
        """

if os.name == "posix":
            return "swig"
        elif os.name == "nt":

elif os.name == "os2":
            # assume swig available in the PATH.
            return "swig.exe"

else:
            raise DistutilsPlatformError, \
                  ("I don't know how to find (much less run) SWIG "
                   "on platform '%s'") % os.name

# find_swig ()

fullname = self.get_ext_fullname(ext_name)
        modpath = fullname.split('.')
        filename = self.get_ext_filename(ext_name)
        filename = os.path.split(filename)[-1]

# returning
        #   package_dir/filename
        return os.path.join(package_dir, filename)

def get_ext_fullname(self, ext_name):
        """Returns the fullname of a given extension name.

Adds the `package.` prefix"""
        if self.package is None:
            return ext_name
        else:
            return self.package + '.' + ext_name

elif sys.platform == 'darwin':
            # Don't use the default code below
            return ext.libraries
        elif sys.platform[:3] == 'aix':
            # Don't use the default code below
            return ext.libraries
        else:
            from distutils import sysconfig
            if sysconfig.get_config_var('Py_ENABLE_SHARED'):
                template = "python%d.%d"
                pythonlib = (template %
                             (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
                return ext.libraries + [pythonlib]
            else:
                return ext.libraries

# class build_ext
command/build_py.py000064400000037722151702014350010354 0ustar00"""distutils.command.build_py

Implements the Distutils 'build_py' command."""

__revision__ = "$Id$"

import os
import sys
from glob import glob

from distutils.core import Command
from distutils.errors import DistutilsOptionError, DistutilsFileError
from distutils.util import convert_path
from distutils import log

class build_py(Command):

description = "\"build\" pure Python modules (copy to build directory)"

user_options = [
        ('build-lib=', 'd', "directory to \"build\" (copy) to"),
        ('compile', 'c', "compile .py to .pyc"),
        ('no-compile', None, "don't compile .py files [default]"),
        ('optimize=', 'O',
         "also compile with optimization: -O1 for \"python -O\", "
         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
        ]

boolean_options = ['compile', 'force']
    negative_opt = {'no-compile' : 'compile'}

def initialize_options(self):
        self.build_lib = None
        self.py_modules = None
        self.package = None
        self.package_data = None
        self.package_dir = None
        self.compile = 0
        self.optimize = 0
        self.force = None

def finalize_options(self):
        self.set_undefined_options('build',
                                   ('build_lib', 'build_lib'),
                                   ('force', 'force'))

# Get the distribution options that are aliases for build_py
        # options -- list of packages and list of modules.
        self.packages = self.distribution.packages
        self.py_modules = self.distribution.py_modules
        self.package_data = self.distribution.package_data
        self.package_dir = {}
        if self.distribution.package_dir:
            for name, path in self.distribution.package_dir.items():
                self.package_dir[name] = convert_path(path)
        self.data_files = self.get_data_files()

# Ick, copied straight from install_lib.py (fancy_getopt needs a
        # type system!  Hell, *everything* needs a type system!!!)
        if not isinstance(self.optimize, int):
            try:
                self.optimize = int(self.optimize)
                assert 0 <= self.optimize <= 2
            except (ValueError, AssertionError):
                raise DistutilsOptionError("optimize must be 0, 1, or 2")

def run(self):
        # XXX copy_file by default preserves atime and mtime.  IMHO this is
        # the right thing to do, but perhaps it should be an option -- in
        # particular, a site administrator might want installed files to
        # reflect the time of installation rather than the last
        # modification time before the installed release.

# XXX copy_file by default preserves mode, which appears to be the
        # wrong thing to do: if a file is read-only in the working
        # directory, we want it to be installed read/write so that the next
        # installation of the same module distribution can overwrite it
        # without problems.  (This might be a Unix-specific issue.)  Thus
        # we turn off 'preserve_mode' when copying to the build directory,
        # since the build directory is supposed to be exactly what the
        # installation will look like (ie. we preserve mode when
        # installing).

# Two options control which modules will be installed: 'packages'
        # and 'py_modules'.  The former lets us work with whole packages, not
        # specifying individual modules at all; the latter is for
        # specifying modules one-at-a-time.

if self.py_modules:
            self.build_modules()
        if self.packages:
            self.build_packages()
            self.build_package_data()

self.byte_compile(self.get_outputs(include_bytecode=0))

def get_data_files(self):
        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
        data = []
        if not self.packages:
            return data
        for package in self.packages:
            # Locate package source directory
            src_dir = self.get_package_dir(package)

# Compute package build directory
            build_dir = os.path.join(*([self.build_lib] + package.split('.')))

# Length of path to strip from found files
            plen = 0
            if src_dir:
                plen = len(src_dir)+1

# Strip directory from globbed filenames
            filenames = [
                file[plen:] for file in self.find_data_files(package, src_dir)
                ]
            data.append((package, src_dir, build_dir, filenames))
        return data

def find_data_files(self, package, src_dir):
        """Return filenames for package's data files in 'src_dir'"""
        globs = (self.package_data.get('', [])
                 + self.package_data.get(package, []))
        files = []
        for pattern in globs:
            # Each pattern has to be converted to a platform-specific path
            filelist = glob(os.path.join(src_dir, convert_path(pattern)))
            # Files that match more than one pattern are only added once
            files.extend([fn for fn in filelist if fn not in files
                and os.path.isfile(fn)])
        return files

def build_package_data(self):
        """Copy data files into build directory"""
        for package, src_dir, build_dir, filenames in self.data_files:
            for filename in filenames:
                target = os.path.join(build_dir, filename)
                self.mkpath(os.path.dirname(target))
                self.copy_file(os.path.join(src_dir, filename), target,
                               preserve_mode=False)

def get_package_dir(self, package):
        """Return the directory, relative to the top of the source
           distribution, where package 'package' should be found
           (at least according to the 'package_dir' option, if any)."""

path = package.split('.')

if not self.package_dir:
            if path:
                return os.path.join(*path)
            else:
                return ''
        else:
            tail = []
            while path:
                try:
                    pdir = self.package_dir['.'.join(path)]
                except KeyError:
                    tail.insert(0, path[-1])
                    del path[-1]
                else:
                    tail.insert(0, pdir)
                    return os.path.join(*tail)
            else:
                # Oops, got all the way through 'path' without finding a
                # match in package_dir.  If package_dir defines a directory
                # for the root (nameless) package, then fallback on it;
                # otherwise, we might as well have not consulted
                # package_dir at all, as we just use the directory implied
                # by 'tail' (which should be the same as the original value
                # of 'path' at this point).
                pdir = self.package_dir.get('')
                if pdir is not None:
                    tail.insert(0, pdir)

if tail:
                    return os.path.join(*tail)
                else:
                    return ''

def check_package(self, package, package_dir):
        # Empty dir name means current directory, which we can probably
        # assume exists.  Also, os.path.exists and isdir don't know about
        # my "empty string means current dir" convention, so we have to
        # circumvent them.
        if package_dir != "":
            if not os.path.exists(package_dir):
                raise DistutilsFileError(
                      "package directory '%s' does not exist" % package_dir)
            if not os.path.isdir(package_dir):
                raise DistutilsFileError(
                       "supposed package directory '%s' exists, "
                       "but is not a directory" % package_dir)

# Require __init__.py for all but the "root package"
        if package:
            init_py = os.path.join(package_dir, "__init__.py")
            if os.path.isfile(init_py):
                return init_py
            else:
                log.warn(("package init file '%s' not found " +
                          "(or not a regular file)"), init_py)

# Either not in a package at all (__init__.py not expected), or
        # __init__.py doesn't exist -- so don't return the filename.
        return None

def check_module(self, module, module_file):
        if not os.path.isfile(module_file):
            log.warn("file %s (for module %s) not found", module_file, module)
            return False
        else:
            return True

def find_package_modules(self, package, package_dir):
        self.check_package(package, package_dir)
        module_files = glob(os.path.join(package_dir, "*.py"))
        modules = []
        setup_script = os.path.abspath(self.distribution.script_name)

for f in module_files:
            abs_f = os.path.abspath(f)
            if abs_f != setup_script:
                module = os.path.splitext(os.path.basename(f))[0]
                modules.append((package, module, f))
            else:
                self.debug_print("excluding %s" % setup_script)
        return modules

def find_modules(self):
        """Finds individually-specified Python modules, ie. those listed by
        module name in 'self.py_modules'.  Returns a list of tuples (package,
        module_base, filename): 'package' is a tuple of the path through
        package-space to the module; 'module_base' is the bare (no
        packages, no dots) module name, and 'filename' is the path to the
        ".py" file (relative to the distribution root) that implements the
        module.
        """
        # Map package names to tuples of useful info about the package:
        #    (package_dir, checked)
        # package_dir - the directory where we'll find source files for
        #   this package
        # checked - true if we have checked that the package directory
        #   is valid (exists, contains __init__.py, ... ?)
        packages = {}

# List of (package, module, filename) tuples to return
        modules = []

# We treat modules-in-packages almost the same as toplevel modules,
        # just the "package" for a toplevel is empty (either an empty
        # string or empty list, depending on context).  Differences:
        #   - don't check for __init__.py in directory for empty package
        for module in self.py_modules:
            path = module.split('.')
            package = '.'.join(path[0:-1])
            module_base = path[-1]

try:
                (package_dir, checked) = packages[package]
            except KeyError:
                package_dir = self.get_package_dir(package)
                checked = 0

if not checked:
                init_py = self.check_package(package, package_dir)
                packages[package] = (package_dir, 1)
                if init_py:
                    modules.append((package, "__init__", init_py))

# XXX perhaps we should also check for just .pyc files
            # (so greedy closed-source bastards can distribute Python
            # modules too)
            module_file = os.path.join(package_dir, module_base + ".py")
            if not self.check_module(module, module_file):
                continue

modules.append((package, module_base, module_file))

return modules

def find_all_modules(self):
        """Compute the list of all modules that will be built, whether
        they are specified one-module-at-a-time ('self.py_modules') or
        by whole packages ('self.packages').  Return a list of tuples
        (package, module, module_file), just like 'find_modules()' and
        'find_package_modules()' do."""
        modules = []
        if self.py_modules:
            modules.extend(self.find_modules())
        if self.packages:
            for package in self.packages:
                package_dir = self.get_package_dir(package)
                m = self.find_package_modules(package, package_dir)
                modules.extend(m)
        return modules

def get_source_files(self):
        return [module[-1] for module in self.find_all_modules()]

def get_module_outfile(self, build_dir, package, module):
        outfile_path = [build_dir] + list(package) + [module + ".py"]
        return os.path.join(*outfile_path)

def get_outputs(self, include_bytecode=1):
        modules = self.find_all_modules()
        outputs = []
        for (package, module, module_file) in modules:
            package = package.split('.')
            filename = self.get_module_outfile(self.build_lib, package, module)
            outputs.append(filename)
            if include_bytecode:
                if self.compile:
                    outputs.append(filename + "c")
                if self.optimize > 0:
                    outputs.append(filename + "o")

outputs += [
            os.path.join(build_dir, filename)
            for package, src_dir, build_dir, filenames in self.data_files
            for filename in filenames
            ]

return outputs

def build_module(self, module, module_file, package):
        if isinstance(package, str):
            package = package.split('.')
        elif not isinstance(package, (list, tuple)):
            raise TypeError(
                  "'package' must be a string (dot-separated), list, or tuple")

# Now put the module source file into the "build" area -- this is
        # easy, we just copy it somewhere under self.build_lib (the build
        # directory for Python source).
        outfile = self.get_module_outfile(self.build_lib, package, module)
        dir = os.path.dirname(outfile)
        self.mkpath(dir)
        return self.copy_file(module_file, outfile, preserve_mode=0)

def build_modules(self):
        modules = self.find_modules()
        for (package, module, module_file) in modules:

# Now "build" the module -- ie. copy the source file to
            # self.build_lib (the build directory for Python source).
            # (Actually, it gets copied to the directory for this package
            # under self.build_lib.)
            self.build_module(module, module_file, package)

def build_packages(self):
        for package in self.packages:

# Get list of (package, module, module_file) tuples based on
            # scanning the package directory.  'package' is only included
            # in the tuple so that 'find_modules()' and
            # 'find_package_tuples()' have a consistent interface; it's
            # ignored here (apart from a sanity check).  Also, 'module' is
            # the *unqualified* module name (ie. no dots, no package -- we
            # already know its package!), and 'module_file' is the path to
            # the .py file, relative to the current directory
            # (ie. including 'package_dir').
            package_dir = self.get_package_dir(package)
            modules = self.find_package_modules(package, package_dir)

# Now loop over the modules we found, "building" each one (just
            # copy it to self.build_lib).
            for (package_, module, module_file) in modules:
                assert package == package_
                self.build_module(module, module_file, package)

def byte_compile(self, files):
        if sys.dont_write_bytecode:
            self.warn('byte-compiling is disabled, skipping.')
            return

from distutils.util import byte_compile
        prefix = self.build_lib
        if prefix[-1] != os.sep:
            prefix = prefix + os.sep

# XXX this code is essentially the same as the 'byte_compile()
        # method of the "install_lib" command, except for the determination
        # of the 'prefix' string.  Hmmm.

if self.compile:
            byte_compile(files, optimize=0,
                         force=self.force, prefix=prefix, dry_run=self.dry_run)
        if self.optimize > 0:
            byte_compile(files, optimize=self.optimize,
                         force=self.force, prefix=prefix, dry_run=self.dry_run)
command/build_py.pyc000064400000026345151702014350010516 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZddlmZm	Z	ddl
mZddlm
Z
d	efd
��YZdS(sHdistutils.command.build_py

Implements the Distutils 'build_py' command.s$Id$i����N(tglob(tCommand(tDistutilsOptionErrortDistutilsFileError(tconvert_path(tlogtbuild_pycBs�eZdZd#d$d&d'd(gZddgZidd6Zd�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd�Zd�Zd�Zd�Zd�Zdd�Zd�Zd �Zd!�Zd"�ZRS()s5"build" pure Python modules (copy to build directory)s
build-lib=tdsdirectory to "build" (copy) totcompiletcscompile .py to .pycs
no-compiles!don't compile .py files [default]s	optimize=tOslalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0]tforcetfs2forcibly build everything (ignore file timestamps)cCsLd|_d|_d|_d|_d|_d|_d|_d|_dS(Ni(	tNonet	build_libt
py_modulestpackagetpackage_datatpackage_dirRtoptimizeR(tself((s2/usr/lib64/python2.7/distutils/command/build_py.pytinitialize_options!s							cCs|jddd�|jj|_|jj|_|jj|_i|_|jjr�x6|jjj�D]\}}t|�|j|<qhWn|j�|_	t
|jt�sy;t|j�|_d|jko�dkns�t
�Wqtt
fk
rtd��qXndS(	NtbuildRRiisoptimize must be 0, 1, or 2(RR(RR(tset_undefined_optionstdistributiontpackagesRRRtitemsRtget_data_filest
data_filest
isinstanceRtinttAssertionErrort
ValueErrorR(Rtnametpath((s2/usr/lib64/python2.7/distutils/command/build_py.pytfinalize_options+s"		)cCsS|jr|j�n|jr6|j�|j�n|j|jdd��dS(Ntinclude_bytecodei(Rt
build_modulesRtbuild_packagestbuild_package_datatbyte_compiletget_outputs(R((s2/usr/lib64/python2.7/distutils/command/build_py.pytrunDs

cCswg}|jr%|j|j��n|jrsxB|jD]4}|j|�}|j||�}|j|�q8Wn|S(s4Compute the list of all modules that will be built, whether
        they are specified one-module-at-a-time ('self.py_modules') or
        by whole packages ('self.packages').  Return a list of tuples
        (package, module, module_file), just like 'find_modules()' and
        'find_package_modules()' do.(RR;RcRR,R_(RR\RRtm((s2/usr/lib64/python2.7/distutils/command/build_py.pytfind_all_moduless		cCs!g|j�D]}|d^q
S(Ni����(Re(RRS((s2/usr/lib64/python2.7/distutils/command/build_py.pytget_source_files-scCs.|gt|�|dg}tjj|�S(Ns.py(tlistR-R"R.(RR5RRStoutfile_path((s2/usr/lib64/python2.7/distutils/command/build_py.pytget_module_outfile0sicCs�|j�}g}x�|D]�\}}}|jd�}|j|j||�}|j|�|r|jr|j|d�n|jdkr�|j|d�q�qqW|g|jD]4\}}}	}
|
D]}tj	j
|	|�^q�q�7}|S(NR+R	ito(ReR/RiRR2RRRR-R"R.(RR$R\toutputsRRSRTRGR4R5R8((s2/usr/lib64/python2.7/distutils/command/build_py.pyR)4s 
	)cCs�t|t�r!|jd�}n$t|ttf�sEtd��n|j|j||�}tj	j
|�}|j|�|j||dd�S(NR+s:'package' must be a string (dot-separated), list, or tupleRBi(
RtstrR/Rgttuplet	TypeErrorRiRR-R"RDRCRE(RRSRTRtoutfiletdir((s2/usr/lib64/python2.7/distutils/command/build_py.pytbuild_moduleIs
cCs=|j�}x*|D]"\}}}|j|||�qWdS(N(RcRq(RR\RRSRT((s2/usr/lib64/python2.7/distutils/command/build_py.pyR%XscCsxxq|jD]f}|j|�}|j||�}x<|D]4\}}}||ksYt�|j|||�q8Wq
WdS(N(RR,R_RRq(RRRR\tpackage_RSRT((s2/usr/lib64/python2.7/distutils/command/build_py.pyR&bsc
Cs�tjr|jd�dSddlm}|j}|dtjkrV|tj}n|jr�||ddd|j	d|d|j
�n|jdkr�||d|jd|j	d|d|j
�ndS(	Ns%byte-compiling is disabled, skipping.i����(R(RiRtprefixtdry_run(tsystdont_write_bytecodeROtdistutils.utilR(RR-tsepRRRtR(RR>R(Rs((s2/usr/lib64/python2.7/distutils/command/build_py.pyR(ws	
		(s
build-lib=Rsdirectory to "build" (copy) to(RR	scompile .py to .pycN(s
no-compileNs!don't compile .py files [default](s	optimize=R
slalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0](RRs2forcibly build everything (ignore file timestamps)(t__name__t
__module__tdescriptionR
tuser_optionstboolean_optionstnegative_optRR#R*RR1R'R,RQRUR_RcReRfRiR)RqR%R&R((((s2/usr/lib64/python2.7/distutils/command/build_py.pyRs8	
	
				
			(				4					
	(t__doc__t__revision__R-RuRtdistutils.coreRtdistutils.errorsRRRwRt	distutilsRR(((s2/usr/lib64/python2.7/distutils/command/build_py.pyt<module>scommand/check.py000064400000013050151702014350007606 0ustar00"""distutils.command.check

Implements the Distutils 'check' command.
"""
__revision__ = "$Id$"

from distutils.core import Command
from distutils.dist import PKG_INFO_ENCODING
from distutils.errors import DistutilsSetupError

try:
    # docutils is installed
    from docutils.utils import Reporter
    from docutils.parsers.rst import Parser
    from docutils import frontend
    from docutils import nodes
    from StringIO import StringIO

class SilentReporter(Reporter):

def __init__(self, source, report_level, halt_level, stream=None,
                     debug=0, encoding='ascii', error_handler='replace'):
            self.messages = []
            Reporter.__init__(self, source, report_level, halt_level, stream,
                              debug, encoding, error_handler)

def system_message(self, level, message, *children, **kwargs):
            self.messages.append((level, message, children, kwargs))
            return nodes.system_message(message, level=level,
                                        type=self.levels[level],
                                        *children, **kwargs)

HAS_DOCUTILS = True
except ImportError:
    # docutils is not installed
    HAS_DOCUTILS = False

class check(Command):
    """This command checks the meta-data of the package.
    """
    description = ("perform some checks on the package")
    user_options = [('metadata', 'm', 'Verify meta-data'),
                    ('restructuredtext', 'r',
                     ('Checks if long string meta-data syntax '
                      'are reStructuredText-compliant')),
                    ('strict', 's',
                     'Will exit with an error if a check fails')]

boolean_options = ['metadata', 'restructuredtext', 'strict']

def initialize_options(self):
        """Sets default values for options."""
        self.restructuredtext = 0
        self.metadata = 1
        self.strict = 0
        self._warnings = 0

def finalize_options(self):
        pass

def warn(self, msg):
        """Counts the number of warnings that occurs."""
        self._warnings += 1
        return Command.warn(self, msg)

def run(self):
        """Runs the command."""
        # perform the various tests
        if self.metadata:
            self.check_metadata()
        if self.restructuredtext:
            if HAS_DOCUTILS:
                self.check_restructuredtext()
            elif self.strict:
                raise DistutilsSetupError('The docutils package is needed.')

# let's raise an error in strict mode, if we have at least
        # one warning
        if self.strict and self._warnings > 0:
            raise DistutilsSetupError('Please correct your package.')

def check_metadata(self):
        """Ensures that all required elements of meta-data are supplied.

name, version, URL, (author and author_email) or
        (maintainer and maintainer_email)).

Warns if any are missing.
        """
        metadata = self.distribution.metadata

missing = []
        for attr in ('name', 'version', 'url'):
            if not (hasattr(metadata, attr) and getattr(metadata, attr)):
                missing.append(attr)

if missing:
            self.warn("missing required meta-data: %s"  % ', '.join(missing))
        if metadata.author:
            if not metadata.author_email:
                self.warn("missing meta-data: if 'author' supplied, " +
                          "'author_email' must be supplied too")
        elif metadata.maintainer:
            if not metadata.maintainer_email:
                self.warn("missing meta-data: if 'maintainer' supplied, " +
                          "'maintainer_email' must be supplied too")
        else:
            self.warn("missing meta-data: either (author and author_email) " +
                      "or (maintainer and maintainer_email) " +
                      "must be supplied")

def check_restructuredtext(self):
        """Checks if the long string fields are reST-compliant."""
        data = self.distribution.get_long_description()
        if not isinstance(data, unicode):
            data = data.decode(PKG_INFO_ENCODING)
        for warning in self._check_rst_data(data):
            line = warning[-1].get('line')
            if line is None:
                warning = warning[1]
            else:
                warning = '%s (line %s)' % (warning[1], line)
            self.warn(warning)

def _check_rst_data(self, data):
        """Returns warnings when the provided data doesn't compile."""
        # the include and csv_table directives need this to be a path
        source_path = self.distribution.script_name or 'setup.py'
        parser = Parser()
        settings = frontend.OptionParser(components=(Parser,)).get_default_values()
        settings.tab_width = 4
        settings.pep_references = None
        settings.rfc_references = None
        reporter = SilentReporter(source_path,
                          settings.report_level,
                          settings.halt_level,
                          stream=settings.warning_stream,
                          debug=settings.debug,
                          encoding=settings.error_encoding,
                          error_handler=settings.error_encoding_error_handler)

document = nodes.document(settings, reporter, source=source_path)
        document.note_source(source_path, -1)
        try:
            parser.parse(data, document)
        except AttributeError as e:
            reporter.messages.append(
                (-1, 'Could not finish the parsing: %s.' % e, '', {}))

return reporter.messages
command/check.pyc000064400000014166151702014350007762 0ustar00�
{fc@s�dZdZddlmZddlmZddlmZypddlm	Z	ddl
mZddlm
Z
dd	lmZdd
lmZde	fd��YZeZWnek
r�eZnXd
efd��YZdS(sCdistutils.command.check

Implements the Distutils 'check' command.
s$Id$i����(tCommand(tPKG_INFO_ENCODING(tDistutilsSetupError(tReporter(tParser(tfrontend(tnodes(tStringIOtSilentReportercBs&eZddddd�Zd�ZRS(itasciitreplacec	Cs/g|_tj||||||||�dS(N(tmessagesRt__init__(tselftsourcetreport_levelt
halt_leveltstreamtdebugtencodingt
error_handler((s//usr/lib64/python2.7/distutils/command/check.pyRs	cOsB|jj||||f�tj|d|d|j|||�S(Ntlevelttype(RtappendRtsystem_messagetlevels(R
Rtmessagetchildrentkwargs((s//usr/lib64/python2.7/distutils/command/check.pyRs
N(t__name__t
__module__tNoneRR(((s//usr/lib64/python2.7/distutils/command/check.pyRstcheckcBsqeZdZdZdddgZdddgZd�Zd�Zd
�Zd�Z	d�Z
d�Zd�ZRS(s6This command checks the meta-data of the package.
    s"perform some checks on the packagetmetadatatmsVerify meta-datatrestructuredtexttrsEChecks if long string meta-data syntax are reStructuredText-complianttstricttss(Will exit with an error if a check failscCs(d|_d|_d|_d|_dS(s Sets default values for options.iiN(R#R!R%t	_warnings(R
((s//usr/lib64/python2.7/distutils/command/check.pytinitialize_options3s			cCsdS(N((R
((s//usr/lib64/python2.7/distutils/command/check.pytfinalize_options:scCs|jd7_tj||�S(s*Counts the number of warnings that occurs.i(R'Rtwarn(R
tmsg((s//usr/lib64/python2.7/distutils/command/check.pyR*=scCsx|jr|j�n|jrMtr2|j�qM|jrMtd��qMn|jrt|jdkrttd��ndS(sRuns the command.sThe docutils package is needed.isPlease correct your package.N(R!tcheck_metadataR#tHAS_DOCUTILStcheck_restructuredtextR%RR'(R
((s//usr/lib64/python2.7/distutils/command/check.pytrunBs	
	
	cCs�|jj}g}x<dD]4}t||�o:t||�s|j|�qqW|rt|jddj|��n|jr�|js�|jdd�q�n>|j	r�|j
s�|jdd	�q�n|jd
dd�d
S(s�Ensures that all required elements of meta-data are supplied.

name, version, URL, (author and author_email) or
        (maintainer and maintainer_email)).

Warns if any are missing.
        tnametversionturlsmissing required meta-data: %ss, s)missing meta-data: if 'author' supplied, s#'author_email' must be supplied toos-missing meta-data: if 'maintainer' supplied, s''maintainer_email' must be supplied toos4missing meta-data: either (author and author_email) s%or (maintainer and maintainer_email) smust be suppliedN(R0R1R2(tdistributionR!thasattrtgetattrRR*tjointauthortauthor_emailt
maintainertmaintainer_email(R
R!tmissingtattr((s//usr/lib64/python2.7/distutils/command/check.pyR,Rs$
						cCs�|jj�}t|t�s0|jt�}nxd|j|�D]S}|djd�}|dkrr|d}nd|d|f}|j	|�q@WdS(s4Checks if the long string fields are reST-compliant.i����tlineis%s (line %s)N(
R3tget_long_descriptiont
isinstancetunicodetdecodeRt_check_rst_datatgetRR*(R
tdatatwarningR=((s//usr/lib64/python2.7/distutils/command/check.pyR.ps
cCs|jjpd}t�}tjdtf�j�}d|_d|_d|_	t
||j|jd|j
d|jd|jd|j�}tj||d|�}|j|d	�y|j||�Wn3tk
r�}|jjd	d
|dif�nX|jS(
s8Returns warnings when the provided data doesn't compile.ssetup.pyt
componentsiRRRRRi����s!Could not finish the parsing: %s.tN(R3tscript_nameRRtOptionParsertget_default_valuest	tab_widthRtpep_referencestrfc_referencesRRRtwarning_streamRterror_encodingterror_encoding_error_handlerRtdocumenttnote_sourcetparsetAttributeErrorRR(R
RDtsource_pathtparsertsettingstreporterRQte((s//usr/lib64/python2.7/distutils/command/check.pyRB}s*									(R!R"sVerify meta-data(R#R$sEChecks if long string meta-data syntax are reStructuredText-compliant(R%R&s(Will exit with an error if a check fails(
RRt__doc__tdescriptiontuser_optionstboolean_optionsR(R)R*R/R,R.RB(((s//usr/lib64/python2.7/distutils/command/check.pyR &s							
N(RZt__revision__tdistutils.coreRtdistutils.distRtdistutils.errorsRtdocutils.utilsRtdocutils.parsers.rstRtdocutilsRRRRtTrueR-tImportErrortFalseR (((s//usr/lib64/python2.7/distutils/command/check.pyt<module>s

command/check.pyo000064400000014166151702014350007776 0ustar00�
{fc@s�dZdZddlmZddlmZddlmZypddlm	Z	ddl
mZddlm
Z
dd	lmZdd
lmZde	fd��YZeZWnek
r�eZnXd
efd��YZdS(sCdistutils.command.check

name, version, URL, (author and author_email) or
        (maintainer and maintainer_email)).

command/clean.py000064400000005376151702014350007627 0ustar00"""distutils.command.clean

Implements the Distutils 'clean' command."""

# contributed by Bastian Kleineidam <calvin@cs.uni-sb.de>, added 2000-03-18

__revision__ = "$Id$"

import os
from distutils.core import Command
from distutils.dir_util import remove_tree
from distutils import log

class clean(Command):

description = "clean up temporary files from 'build' command"
    user_options = [
        ('build-base=', 'b',
         "base build directory (default: 'build.build-base')"),
        ('build-lib=', None,
         "build directory for all modules (default: 'build.build-lib')"),
        ('build-temp=', 't',
         "temporary build directory (default: 'build.build-temp')"),
        ('build-scripts=', None,
         "build directory for scripts (default: 'build.build-scripts')"),
        ('bdist-base=', None,
         "temporary directory for built distributions"),
        ('all', 'a',
         "remove all build output, not just temporary by-products")
    ]

boolean_options = ['all']

def initialize_options(self):
        self.build_base = None
        self.build_lib = None
        self.build_temp = None
        self.build_scripts = None
        self.bdist_base = None
        self.all = None

def finalize_options(self):
        self.set_undefined_options('build',
                                   ('build_base', 'build_base'),
                                   ('build_lib', 'build_lib'),
                                   ('build_scripts', 'build_scripts'),
                                   ('build_temp', 'build_temp'))
        self.set_undefined_options('bdist',
                                   ('bdist_base', 'bdist_base'))

def run(self):
        # remove the build/temp.<plat> directory (unless it's already
        # gone)
        if os.path.exists(self.build_temp):
            remove_tree(self.build_temp, dry_run=self.dry_run)
        else:
            log.debug("'%s' does not exist -- can't clean it",
                      self.build_temp)

if self.all:
            # remove build directories
            for directory in (self.build_lib,
                              self.bdist_base,
                              self.build_scripts):
                if os.path.exists(directory):
                    remove_tree(directory, dry_run=self.dry_run)
                else:
                    log.warn("'%s' does not exist -- can't clean it",
                             directory)

# just for the heck of it, try to remove the base build directory:
        # we might have emptied it right now, but if not we don't care
        if not self.dry_run:
            try:
                os.rmdir(self.build_base)
                log.info("removing '%s'", self.build_base)
            except OSError:
                pass

# class clean
command/clean.pyo000064400000005775151702014350010011 0ustar00�
{fc@sbdZdZddlZddlmZddlmZddlmZdefd��YZ	dS(	sBdistutils.command.clean

Implements the Distutils 'clean' command.s$Id$i����N(tCommand(tremove_tree(tlogtcleancBsJeZdZddddddgZd
gZd�Zd�Zd�ZRS(s-clean up temporary files from 'build' commandsbuild-base=tbs2base build directory (default: 'build.build-base')s
build-lib=s<build directory for all modules (default: 'build.build-lib')sbuild-temp=tts7temporary build directory (default: 'build.build-temp')sbuild-scripts=s<build directory for scripts (default: 'build.build-scripts')sbdist-base=s+temporary directory for built distributionstalltas7remove all build output, not just temporary by-productscCs:d|_d|_d|_d|_d|_d|_dS(N(tNonet
build_baset	build_libt
build_tempt
build_scriptst
bdist_baseR(tself((s//usr/lib64/python2.7/distutils/command/clean.pytinitialize_options"s					cCs-|jddd	d
d�|jdd�dS(
NtbuildR	R
RRtbdistR
(R	R	(R
R
(RR(RR(R
R
(tset_undefined_options(R((s//usr/lib64/python2.7/distutils/command/clean.pytfinalize_options*s		cCs�tjj|j�r.t|jd|j�ntjd|j�|jr�x[|j	|j
|jfD]>}tjj|�r�t|d|j�qctjd|�qcWn|js�y'tj
|j�tjd|j�Wq�tk
r�q�XndS(Ntdry_runs%'%s' does not exist -- can't clean its
removing '%s'(tostpathtexistsRRRRtdebugRR
R
RtwarntrmdirR	tinfotOSError(Rt	directory((s//usr/lib64/python2.7/distutils/command/clean.pytrun3s$	
				
(sbuild-base=Rs2base build directory (default: 'build.build-base')N(s
build-lib=Ns<build directory for all modules (default: 'build.build-lib')(sbuild-temp=Rs7temporary build directory (default: 'build.build-temp')(sbuild-scripts=Ns<build directory for scripts (default: 'build.build-scripts')(sbdist-base=Ns+temporary directory for built distributions(RRs7remove all build output, not just temporary by-products(	t__name__t
__module__tdescriptionRtuser_optionstboolean_optionsRRR(((s//usr/lib64/python2.7/distutils/command/clean.pyRs"					(
t__doc__t__revision__Rtdistutils.coreRtdistutils.dir_utilRt	distutilsRR(((s//usr/lib64/python2.7/distutils/command/clean.pyt<module>scommand/command_template000064400000001317151702014350011416 0ustar00"""distutils.command.x

Implements the Distutils 'x' command.
"""

# created 2000/mm/dd, John Doe

__revision__ = "$Id$"

from distutils.core import Command

class x (Command):

# Brief (40-50 characters) description of the command
    description = ""

# List of option tuples: long name, short name (None if no short
    # name), and help string.
    user_options = [('', '',
                     ""),
                   ]

def initialize_options (self):
        self. = None
        self. = None
        self. = None

# initialize_options()

def finalize_options (self):
        if self.x is None:
            self.x =

# finalize_options()

def run (self):

# run()

# class x
command/install.py000064400000063230151702014350010204 0ustar00"""distutils.command.install

Implements the Distutils 'install' command."""

from distutils import log

# This module should be kept compatible with Python 2.1.

__revision__ = "$Id$"

import sys, os, string
from types import *
from distutils.core import Command
from distutils.debug import DEBUG
from distutils.sysconfig import get_config_vars
from distutils.errors import DistutilsPlatformError
from distutils.file_util import write_file
from distutils.util import convert_path, subst_vars, change_root
from distutils.util import get_platform
from distutils.errors import DistutilsOptionError
from site import USER_BASE
from site import USER_SITE

if sys.version < "2.2":
    WINDOWS_SCHEME = {
        'purelib': '$base',
        'platlib': '$base',
        'headers': '$base/Include/$dist_name',
        'scripts': '$base/Scripts',
        'data'   : '$base',
    }
else:
    WINDOWS_SCHEME = {
        'purelib': '$base/Lib/site-packages',
        'platlib': '$base/Lib/site-packages',
        'headers': '$base/Include/$dist_name',
        'scripts': '$base/Scripts',
        'data'   : '$base',
    }

INSTALL_SCHEMES = {
    'unix_prefix': {
        'purelib': '$base/lib/python$py_version_short/site-packages',
        'platlib': '$platbase/lib64/python$py_version_short/site-packages',
        'headers': '$base/include/python$py_version_short/$dist_name',
        'scripts': '$base/bin',
        'data'   : '$base',
        },
    'unix_home': {
        'purelib': '$base/lib/python',
        'platlib': '$base/lib64/python',
        'headers': '$base/include/python/$dist_name',
        'scripts': '$base/bin',
        'data'   : '$base',
        },
    'unix_user': {
        'purelib': '$usersite',
        'platlib': '$usersite',
        'headers': '$userbase/include/python$py_version_short/$dist_name',
        'scripts': '$userbase/bin',
        'data'   : '$userbase',
        },
    'nt': WINDOWS_SCHEME,
    'nt_user': {
        'purelib': '$usersite',
        'platlib': '$usersite',
        'headers': '$userbase/Python$py_version_nodot/Include/$dist_name',
        'scripts': '$userbase/Scripts',
        'data'   : '$userbase',
        },
    'os2': {
        'purelib': '$base/Lib/site-packages',
        'platlib': '$base/Lib/site-packages',
        'headers': '$base/Include/$dist_name',
        'scripts': '$base/Scripts',
        'data'   : '$base',
        },
    'os2_home': {
        'purelib': '$usersite',
        'platlib': '$usersite',
        'headers': '$userbase/include/python$py_version_short/$dist_name',
        'scripts': '$userbase/bin',
        'data'   : '$userbase',
        },
    }

# The keys to an installation scheme; if any new types of files are to be
# installed, be sure to add an entry to every installation scheme above,
# and to SCHEME_KEYS here.
SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data')

class install (Command):

description = "install everything from build directory"

user_options = [
        # Select installation scheme and set base director(y|ies)
        ('prefix=', None,
         "installation prefix"),
        ('exec-prefix=', None,
         "(Unix only) prefix for platform-specific files"),
        ('home=', None,
         "(Unix only) home directory to install under"),
        ('user', None,
         "install in user site-package '%s'" % USER_SITE),

# Or, just set the base director(y|ies)
        ('install-base=', None,
         "base installation directory (instead of --prefix or --home)"),
        ('install-platbase=', None,
         "base installation directory for platform-specific files " +
         "(instead of --exec-prefix or --home)"),
        ('root=', None,
         "install everything relative to this alternate root directory"),

# Or, explicitly set the installation scheme
        ('install-purelib=', None,
         "installation directory for pure Python module distributions"),
        ('install-platlib=', None,
         "installation directory for non-pure module distributions"),
        ('install-lib=', None,
         "installation directory for all module distributions " +
         "(overrides --install-purelib and --install-platlib)"),

('install-headers=', None,
         "installation directory for C/C++ headers"),
        ('install-scripts=', None,
         "installation directory for Python scripts"),
        ('install-data=', None,
         "installation directory for data files"),

# Byte-compilation options -- see install_lib.py for details, as
        # these are duplicated from there (but only install_lib does
        # anything with them).
        ('compile', 'c', "compile .py to .pyc [default]"),
        ('no-compile', None, "don't compile .py files"),
        ('optimize=', 'O',
         "also compile with optimization: -O1 for \"python -O\", "
         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),

# Miscellaneous control options
        ('force', 'f',
         "force installation (overwrite any existing files)"),
        ('skip-build', None,
         "skip rebuilding everything (for testing/debugging)"),

# Where to install documentation (eventually!)
        #('doc-format=', None, "format of documentation to generate"),
        #('install-man=', None, "directory for Unix man pages"),
        #('install-html=', None, "directory for HTML documentation"),
        #('install-info=', None, "directory for GNU info files"),

('record=', None,
         "filename in which to record list of installed files"),
        ]

boolean_options = ['compile', 'force', 'skip-build', 'user']
    negative_opt = {'no-compile' : 'compile'}

def initialize_options (self):

# High-level options: these select both an installation base
        # and scheme.
        self.prefix = None
        self.exec_prefix = None
        self.home = None
        self.user = 0

# These select only the installation base; it's up to the user to
        # specify the installation scheme (currently, that means supplying
        # the --install-{platlib,purelib,scripts,data} options).
        self.install_base = None
        self.install_platbase = None
        self.root = None

# These options are the actual installation directories; if not
        # supplied by the user, they are filled in using the installation
        # scheme implied by prefix/exec-prefix/home and the contents of
        # that installation scheme.
        self.install_purelib = None     # for pure module distributions
        self.install_platlib = None     # non-pure (dists w/ extensions)
        self.install_headers = None     # for C/C++ headers
        self.install_lib = None         # set to either purelib or platlib
        self.install_scripts = None
        self.install_data = None
        self.install_userbase = USER_BASE
        self.install_usersite = USER_SITE

self.compile = None
        self.optimize = None

# These two are for putting non-packagized distributions into their
        # own directory and creating a .pth file if it makes sense.
        # 'extra_path' comes from the setup file; 'install_path_file' can
        # be turned off if it makes no sense to install a .pth file.  (But
        # better to install it uselessly than to guess wrong and not
        # install it when it's necessary and would be used!)  Currently,
        # 'install_path_file' is always true unless some outsider meddles
        # with it.
        self.extra_path = None
        self.install_path_file = 1

# 'force' forces installation, even if target files are not
        # out-of-date.  'skip_build' skips running the "build" command,
        # handy if you know it's not necessary.  'warn_dir' (which is *not*
        # a user option, it's just there so the bdist_* commands can turn
        # it off) determines whether we warn about installing to a
        # directory not in sys.path.
        self.force = 0
        self.skip_build = 0
        self.warn_dir = 1

# These are only here as a conduit from the 'build' command to the
        # 'install_*' commands that do the real work.  ('build_base' isn't
        # actually used anywhere, but it might be useful in future.)  They
        # are not user options, because if the user told the install
        # command where the build directory is, that wouldn't affect the
        # build command.
        self.build_base = None
        self.build_lib = None

# Not defined yet because we don't know anything about
        # documentation yet.
        #self.install_man = None
        #self.install_html = None
        #self.install_info = None

self.record = None

# -- Option finalizing methods -------------------------------------
    # (This is rather more involved than for most commands,
    # because this is where the policy for installing third-
    # party Python modules on various platforms given a wide
    # array of user input is decided.  Yes, it's quite complex!)

def finalize_options (self):

# This method (and its pliant slaves, like 'finalize_unix()',
        # 'finalize_other()', and 'select_scheme()') is where the default
        # installation directories for modules, extension modules, and
        # anything else we care to install from a Python module
        # distribution.  Thus, this code makes a pretty important policy
        # statement about how third-party stuff is added to a Python
        # installation!  Note that the actual work of installation is done
        # by the relatively simple 'install_*' commands; they just take
        # their orders from the installation directory options determined
        # here.

# Check for errors/inconsistencies in the options; first, stuff
        # that's wrong on any platform.

if ((self.prefix or self.exec_prefix or self.home) and
            (self.install_base or self.install_platbase)):
            raise DistutilsOptionError, \
                  ("must supply either prefix/exec-prefix/home or " +
                   "install-base/install-platbase -- not both")

if self.home and (self.prefix or self.exec_prefix):
            raise DistutilsOptionError, \
                  "must supply either home or prefix/exec-prefix -- not both"

if self.user and (self.prefix or self.exec_prefix or self.home or
                self.install_base or self.install_platbase):
            raise DistutilsOptionError("can't combine user with prefix, "
                                       "exec_prefix/home, or install_(plat)base")

# Next, stuff that's wrong (or dubious) only on certain platforms.
        if os.name != "posix":
            if self.exec_prefix:
                self.warn("exec-prefix option ignored on this platform")
                self.exec_prefix = None

# Now the interesting logic -- so interesting that we farm it out
        # to other methods.  The goal of these methods is to set the final
        # values for the install_{lib,scripts,data,...}  options, using as
        # input a heady brew of prefix, exec_prefix, home, install_base,
        # install_platbase, user-supplied versions of
        # install_{purelib,platlib,lib,scripts,data,...}, and the
        # INSTALL_SCHEME dictionary above.  Phew!

self.dump_dirs("pre-finalize_{unix,other}")

if os.name == 'posix':
            self.finalize_unix()
        else:
            self.finalize_other()

self.dump_dirs("post-finalize_{unix,other}()")

# Expand configuration variables, tilde, etc. in self.install_base
        # and self.install_platbase -- that way, we can use $base or
        # $platbase in the other installation directories and not worry
        # about needing recursive variable expansion (shudder).

py_version = (string.split(sys.version))[0]
        (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
        self.config_vars = {'dist_name': self.distribution.get_name(),
                            'dist_version': self.distribution.get_version(),
                            'dist_fullname': self.distribution.get_fullname(),
                            'py_version': py_version,
                            'py_version_short': py_version[0:3],
                            'py_version_nodot': py_version[0] + py_version[2],
                            'sys_prefix': prefix,
                            'prefix': prefix,
                            'sys_exec_prefix': exec_prefix,
                            'exec_prefix': exec_prefix,
                            'userbase': self.install_userbase,
                            'usersite': self.install_usersite,
                           }
        self.expand_basedirs()

self.dump_dirs("post-expand_basedirs()")

# Now define config vars for the base directories so we can expand
        # everything else.
        self.config_vars['base'] = self.install_base
        self.config_vars['platbase'] = self.install_platbase

if DEBUG:
            from pprint import pprint
            print "config vars:"
            pprint(self.config_vars)

# Expand "~" and configuration variables in the installation
        # directories.
        self.expand_dirs()

self.dump_dirs("post-expand_dirs()")

# Create directories in the home dir:
        if self.user:
            self.create_home_path()

# Pick the actual directory to install all modules to: either
        # install_purelib or install_platlib, depending on whether this
        # module distribution is pure or not.  Of course, if the user
        # already specified install_lib, use their selection.
        if self.install_lib is None:
            if self.distribution.ext_modules: # has extensions: non-pure
                self.install_lib = self.install_platlib
            else:
                self.install_lib = self.install_purelib

# Convert directories from Unix /-separated syntax to the local
        # convention.
        self.convert_paths('lib', 'purelib', 'platlib',
                           'scripts', 'data', 'headers',
                           'userbase', 'usersite')

# Well, we're not actually fully completely finalized yet: we still
        # have to deal with 'extra_path', which is the hack for allowing
        # non-packagized module distributions (hello, Numerical Python!) to
        # get their own directories.
        self.handle_extra_path()
        self.install_libbase = self.install_lib # needed for .pth file
        self.install_lib = os.path.join(self.install_lib, self.extra_dirs)

# If a new root directory was supplied, make all the installation
        # dirs relative to it.
        if self.root is not None:
            self.change_roots('libbase', 'lib', 'purelib', 'platlib',
                              'scripts', 'data', 'headers')

self.dump_dirs("after prepending root")

# Find out the build directories, ie. where to install from.
        self.set_undefined_options('build',
                                   ('build_base', 'build_base'),
                                   ('build_lib', 'build_lib'))

# Punt on doc directories for now -- after all, we're punting on
        # documentation completely!

# finalize_options ()

def dump_dirs (self, msg):
        if DEBUG:
            from distutils.fancy_getopt import longopt_xlate
            print msg + ":"
            for opt in self.user_options:
                opt_name = opt[0]
                if opt_name[-1] == "=":
                    opt_name = opt_name[0:-1]
                if opt_name in self.negative_opt:
                    opt_name = string.translate(self.negative_opt[opt_name],
                                                longopt_xlate)
                    val = not getattr(self, opt_name)
                else:
                    opt_name = string.translate(opt_name, longopt_xlate)
                    val = getattr(self, opt_name)
                print "  %s: %s" % (opt_name, val)

def finalize_unix (self):

if self.install_base is not None or self.install_platbase is not None:
            if ((self.install_lib is None and
                 self.install_purelib is None and
                 self.install_platlib is None) or
                self.install_headers is None or
                self.install_scripts is None or
                self.install_data is None):
                raise DistutilsOptionError, \
                      ("install-base or install-platbase supplied, but "
                      "installation scheme is incomplete")
            return

if self.user:
            if self.install_userbase is None:
                raise DistutilsPlatformError(
                    "User base directory is not specified")
            self.install_base = self.install_platbase = self.install_userbase
            self.select_scheme("unix_user")
        elif self.home is not None:
            self.install_base = self.install_platbase = self.home
            self.select_scheme("unix_home")
        else:
            if self.prefix is None:
                if self.exec_prefix is not None:
                    raise DistutilsOptionError, \
                          "must not supply exec-prefix without prefix"

self.prefix = os.path.normpath(sys.prefix)
                self.exec_prefix = os.path.normpath(sys.exec_prefix)

else:
                if self.exec_prefix is None:
                    self.exec_prefix = self.prefix

self.install_base = self.prefix
            self.install_platbase = self.exec_prefix
            self.select_scheme("unix_prefix")

# finalize_unix ()

def finalize_other (self):          # Windows and Mac OS for now

if self.user:
            if self.install_userbase is None:
                raise DistutilsPlatformError(
                    "User base directory is not specified")
            self.install_base = self.install_platbase = self.install_userbase
            self.select_scheme(os.name + "_user")
        elif self.home is not None:
            self.install_base = self.install_platbase = self.home
            self.select_scheme("unix_home")
        else:
            if self.prefix is None:
                self.prefix = os.path.normpath(sys.prefix)

self.install_base = self.install_platbase = self.prefix
            try:
                self.select_scheme(os.name)
            except KeyError:
                raise DistutilsPlatformError, \
                      "I don't know how to install stuff on '%s'" % os.name

# finalize_other ()

def select_scheme (self, name):
        # it's the caller's problem if they supply a bad name!
        scheme = INSTALL_SCHEMES[name]
        for key in SCHEME_KEYS:
            attrname = 'install_' + key
            if getattr(self, attrname) is None:
                setattr(self, attrname, scheme[key])

def _expand_attrs (self, attrs):
        for attr in attrs:
            val = getattr(self, attr)
            if val is not None:
                if os.name == 'posix' or os.name == 'nt':
                    val = os.path.expanduser(val)
                val = subst_vars(val, self.config_vars)
                setattr(self, attr, val)

def expand_basedirs (self):
        self._expand_attrs(['install_base',
                            'install_platbase',
                            'root'])

def expand_dirs (self):
        self._expand_attrs(['install_purelib',
                            'install_platlib',
                            'install_lib',
                            'install_headers',
                            'install_scripts',
                            'install_data',])

def convert_paths (self, *names):
        for name in names:
            attr = "install_" + name
            setattr(self, attr, convert_path(getattr(self, attr)))

def handle_extra_path (self):

if self.extra_path is None:
            self.extra_path = self.distribution.extra_path

if self.extra_path is not None:
            if type(self.extra_path) is StringType:
                self.extra_path = string.split(self.extra_path, ',')

if len(self.extra_path) == 1:
                path_file = extra_dirs = self.extra_path[0]
            elif len(self.extra_path) == 2:
                (path_file, extra_dirs) = self.extra_path
            else:
                raise DistutilsOptionError, \
                      ("'extra_path' option must be a list, tuple, or "
                      "comma-separated string with 1 or 2 elements")

# convert to local form in case Unix notation used (as it
            # should be in setup scripts)
            extra_dirs = convert_path(extra_dirs)

else:
            path_file = None
            extra_dirs = ''

# XXX should we warn if path_file and not extra_dirs? (in which
        # case the path file would be harmless but pointless)
        self.path_file = path_file
        self.extra_dirs = extra_dirs

# handle_extra_path ()

def change_roots (self, *names):
        for name in names:
            attr = "install_" + name
            setattr(self, attr, change_root(self.root, getattr(self, attr)))

def create_home_path(self):
        """Create directories under ~
        """
        if not self.user:
            return
        home = convert_path(os.path.expanduser("~"))
        for name, path in self.config_vars.iteritems():
            if path.startswith(home) and not os.path.isdir(path):
                self.debug_print("os.makedirs('%s', 0700)" % path)
                os.makedirs(path, 0700)

# -- Command execution methods -------------------------------------

def run (self):

# Obviously have to build before we can install
        if not self.skip_build:
            self.run_command('build')
            # If we built for any other platform, we can't install.
            build_plat = self.distribution.get_command_obj('build').plat_name
            # check warn_dir - it is a clue that the 'install' is happening
            # internally, and not to sys.path, so we don't check the platform
            # matches what we are running.
            if self.warn_dir and build_plat != get_platform():
                raise DistutilsPlatformError("Can't install when "
                                             "cross-compiling")

# Run all sub-commands (at least those that need to be run)
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

if self.path_file:
            self.create_path_file()

# write list of installed files, if requested.
        if self.record:
            outputs = self.get_outputs()
            if self.root:               # strip any package prefix
                root_len = len(self.root)
                for counter in xrange(len(outputs)):
                    outputs[counter] = outputs[counter][root_len:]
            self.execute(write_file,
                         (self.record, outputs),
                         "writing list of installed files to '%s'" %
                         self.record)

sys_path = map(os.path.normpath, sys.path)
        sys_path = map(os.path.normcase, sys_path)
        install_lib = os.path.normcase(os.path.normpath(self.install_lib))
        if (self.warn_dir and
            not (self.path_file and self.install_path_file) and
            install_lib not in sys_path):
            log.debug(("modules installed to '%s', which is not in "
                       "Python's module search path (sys.path) -- "
                       "you'll have to change the search path yourself"),
                       self.install_lib)

# run ()

def create_path_file (self):
        filename = os.path.join(self.install_libbase,
                                self.path_file + ".pth")
        if self.install_path_file:
            self.execute(write_file,
                         (filename, [self.extra_dirs]),
                         "creating %s" % filename)
        else:
            self.warn("path file '%s' not created" % filename)

# -- Reporting methods ---------------------------------------------

def get_outputs (self):
        # Assemble the outputs of all the sub-commands.
        outputs = []
        for cmd_name in self.get_sub_commands():
            cmd = self.get_finalized_command(cmd_name)
            # Add the contents of cmd.get_outputs(), ensuring
            # that outputs doesn't contain duplicate entries
            for filename in cmd.get_outputs():
                if filename not in outputs:
                    outputs.append(filename)

if self.path_file and self.install_path_file:
            outputs.append(os.path.join(self.install_libbase,
                                        self.path_file + ".pth"))

return outputs

def get_inputs (self):
        # XXX gee, this looks familiar ;-(
        inputs = []
        for cmd_name in self.get_sub_commands():
            cmd = self.get_finalized_command(cmd_name)
            inputs.extend(cmd.get_inputs())

return inputs

# -- Predicates for sub-command list -------------------------------

def has_lib (self):
        """Return true if the current distribution has any Python
        modules to install."""
        return (self.distribution.has_pure_modules() or
                self.distribution.has_ext_modules())

def has_headers (self):
        return self.distribution.has_headers()

def has_scripts (self):
        return self.distribution.has_scripts()

def has_data (self):
        return self.distribution.has_data_files()

# 'sub_commands': a list of commands this command might have to run to
    # get its work done.  See cmd.py for more info.
    sub_commands = [('install_lib',     has_lib),
                    ('install_headers', has_headers),
                    ('install_scripts', has_scripts),
                    ('install_data',    has_data),
                    ('install_egg_info', lambda self:True),
                   ]

# class install
command/install.pyc000064400000040662151702014350010353 0ustar00�
{fc@s�dZddlmZdZddlZddlZddlZddlTddlm	Z	ddl
mZddlm
Z
dd	lmZdd
lmZddlmZmZmZddlmZdd
lmZddlmZddlmZejdkr1idd6dd6dd6dd6dd6Zn)idd6dd6dd6dd6dd6Ziidd6dd6dd6dd6dd6d6idd6d d6d!d6dd6dd6d"6id#d6d#d6d$d6d%d6d&d6d'6ed(6id#d6d#d6d)d6d*d6d&d6d+6idd6dd6dd6dd6dd6d,6id#d6d#d6d$d6d%d6d&d6d-6Zd0Zd.e	fd/��YZdS(1sFdistutils.command.install

Implements the Distutils 'install' command.i����(tlogs$Id$N(t*(tCommand(tDEBUG(tget_config_vars(tDistutilsPlatformError(t
write_file(tconvert_patht
subst_varstchange_root(tget_platform(tDistutilsOptionError(t	USER_BASE(t	USER_SITEs2.2s$basetpurelibtplatlibs$base/Include/$dist_nametheaderss
$base/Scriptstscriptstdatas$base/Lib/site-packagess/$base/lib/python$py_version_short/site-packagess5$platbase/lib64/python$py_version_short/site-packagess0$base/include/python$py_version_short/$dist_names	$base/bintunix_prefixs$base/lib/pythons$base/lib64/pythons$base/include/python/$dist_namet	unix_homes	$usersites4$userbase/include/python$py_version_short/$dist_names
$userbase/bins	$userbaset	unix_usertnts4$userbase/Python$py_version_nodot/Include/$dist_names$userbase/Scriptstnt_usertos2tos2_hometinstallcBs�eZdZdHdIdJddGdefdKddGdd
fdLdMdNddGddfdOdPdQdRdSdTdUdVdWgZdd%d(dgZidd 6Zd,�Zd-�Z	d.�Z
d/�Zd0�Zd1�Z
d2�Zd3�Zd4�Zd5�Zd6�Zd7�Zd8�Zd9�Zd:�Zd;�Zd<�Zd=�Zd>�Zd?�Zd@�ZdAefdBefdCefdDefdEdF�fgZRS(Xs'install everything from build directorysprefix=sinstallation prefixsexec-prefix=s.(Unix only) prefix for platform-specific filesshome=s+(Unix only) home directory to install undertusers!install in user site-package '%s's
install-base=s;base installation directory (instead of --prefix or --home)sinstall-platbase=s8base installation directory for platform-specific files s$(instead of --exec-prefix or --home)sroot=s<install everything relative to this alternate root directorysinstall-purelib=s;installation directory for pure Python module distributionssinstall-platlib=s8installation directory for non-pure module distributionssinstall-lib=s4installation directory for all module distributions s3(overrides --install-purelib and --install-platlib)sinstall-headers=s(installation directory for C/C++ headerssinstall-scripts=s)installation directory for Python scriptss
install-data=s%installation directory for data filestcompiletcscompile .py to .pyc [default]s
no-compilesdon't compile .py filess	optimize=tOslalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0]tforcetfs1force installation (overwrite any existing files)s
skip-builds2skip rebuilding everything (for testing/debugging)srecord=s3filename in which to record list of installed filescCs�d|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_d|_d|_
t|_t|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_dS(Nii(tNonetprefixtexec_prefixthomeRtinstall_basetinstall_platbasetroottinstall_purelibtinstall_platlibtinstall_headerstinstall_libtinstall_scriptstinstall_dataRtinstall_userbaseR
tinstall_usersiteRtoptimizet
extra_pathtinstall_path_fileRt
skip_buildtwarn_dirt
build_baset	build_libtrecord(tself((s1/usr/lib64/python2.7/distutils/command/install.pytinitialize_options�s2																	
							c	CsL|js|js|jr=|js-|jr=tdd�n|jrd|jsX|jrdtd�n|jr�|js�|js�|js�|js�|jr�td��ntjdkr�|jr�|j	d�d|_q�n|jd�tjdkr|j�n
|j
�|jd�tjtj�d	}td
d�\}}i|jj�d6|jj�d
6|jj�d6|d6|d	d!d6|d	|dd6|d6|d
6|d6|d6|jd6|jd6|_|j�|jd�|j|jd<|j|jd<tr;ddlm}dGH||j�n|j�|jd�|jrh|j�n|jdkr�|jj r�|j!|_q�|j"|_n|j#dd d!d"d#d$dd�|j$�|j|_%tj&j'|j|j(�|_|j)dk	r(|j*d%dd d!d"d#d$�n|jd&�|j+d'd*d+�dS(,Ns.must supply either prefix/exec-prefix/home or s)install-base/install-platbase -- not boths9must supply either home or prefix/exec-prefix -- not bothsGcan't combine user with prefix, exec_prefix/home, or install_(plat)basetposixs+exec-prefix option ignored on this platformspre-finalize_{unix,other}spost-finalize_{unix,other}()iR"R#t	dist_nametdist_versiont
dist_fullnamet
py_versionitpy_version_shortitpy_version_nodott
sys_prefixtsys_exec_prefixtuserbasetusersitespost-expand_basedirs()tbasetplatbasei����(tpprintsconfig vars:spost-expand_dirs()tlibRRRRRtlibbasesafter prepending roottbuildR5R6(R5R5(R6R6(,R"R#R$R%R&RRtostnametwarnR!t	dump_dirst
finalize_unixtfinalize_othertstringtsplittsystversionRtdistributiontget_nametget_versiontget_fullnameR.R/tconfig_varstexpand_basedirsRRGtexpand_dirstcreate_home_pathR+text_modulesR)R(t
convert_pathsthandle_extra_pathtinstall_libbasetpathtjoint
extra_dirsR'tchange_rootstset_undefined_options(R8R>R"R#RG((s1/usr/lib64/python2.7/distutils/command/install.pytfinalize_options�s~
	$

cCs�tr�ddlm}|dGHx�|jD]�}|d}|ddkrY|dd!}n||jkr�tj|j||�}t||�}n!tj||�}t||�}d||fGHq)WndS(Ni����(t
longopt_xlatet:it=s  %s: %s(Rtdistutils.fancy_getoptRgtuser_optionstnegative_optRQt	translatetgetattr(R8tmsgRgtopttopt_nametval((s1/usr/lib64/python2.7/distutils/command/install.pyRN~s	
	cCs�|jdk	s|jdk	r�|jdkrK|jdkrK|jdksx|jdksx|jdksx|jdkr�t	d�ndS|j
r�|jdkr�td��n|j|_|_|j
d�n�|jdk	r|j|_|_|j
d�n�|jdkra|jdk	r.t	d�ntjjtj�|_tjjtj�|_n|jdkr|j|_n|j|_|j|_|j
d�dS(NsPinstall-base or install-platbase supplied, but installation scheme is incompletes$User base directory is not specifiedRRs*must not supply exec-prefix without prefixR(R%R!R&R+R(R)R*R,R-RRR.Rt
select_schemeR$R"R#RKRatnormpathRS(R8((s1/usr/lib64/python2.7/distutils/command/install.pyRO�s<			cCs�|jrQ|jdkr'td��n|j|_|_|jtjd�n�|j	dk	r�|j	|_|_|jd�nu|j
dkr�tjjt
j
�|_
n|j
|_|_y|jtj�Wn!tk
r�tdtj�nXdS(Ns$User base directory is not specifiedt_userRs)I don't know how to install stuff on '%s'(RR.R!RR%R&RsRKRLR$R"RaRtRStKeyError(R8((s1/usr/lib64/python2.7/distutils/command/install.pyRP�s"	
cCsUt|}xDtD]<}d|}t||�dkrt||||�qqWdS(Ntinstall_(tINSTALL_SCHEMEStSCHEME_KEYSRnR!tsetattr(R8RLtschemetkeytattrname((s1/usr/lib64/python2.7/distutils/command/install.pyRs�s

cCs�x�|D]y}t||�}|dk	rtjdksFtjdkr[tjj|�}nt||j�}t|||�qqWdS(NR:R(	RnR!RKRLRat
expanduserRRYRz(R8tattrstattrRr((s1/usr/lib64/python2.7/distutils/command/install.pyt
_expand_attrs�s
cCs|jdddg�dS(NR%R&R'(R�(R8((s1/usr/lib64/python2.7/distutils/command/install.pyRZ�s	cCs#|jddddddg�dS(NR(R)R+R*R,R-(R�(R8((s1/usr/lib64/python2.7/distutils/command/install.pyR[�s	cGs>x7|D]/}d|}t||tt||���qWdS(NRw(RzRRn(R8tnamesRLR�((s1/usr/lib64/python2.7/distutils/command/install.pyR^�s
cCs�|jdkr!|jj|_n|jdk	r�t|j�tkr`tj|jd�|_nt|j�dkr�|jd}}n0t|j�dkr�|j\}}n	td�t	|�}nd}d}||_
||_dS(Nt,iiisY'extra_path' option must be a list, tuple, or comma-separated string with 1 or 2 elementst(R1R!RUttypet
StringTypeRQRRtlenRRt	path_fileRc(R8R�Rc((s1/usr/lib64/python2.7/distutils/command/install.pyR_�s 	c	GsDx=|D]5}d|}t||t|jt||���qWdS(NRw(RzR	R'Rn(R8R�RLR�((s1/usr/lib64/python2.7/distutils/command/install.pyRds
cCs�|js
dSttjjd��}xc|jj�D]R\}}|j|�r5tjj|�r5|j	d|�tj
|d�q5q5WdS(s#Create directories under ~
        Nt~sos.makedirs('%s', 0700)i�(RRRKRaR~RYt	iteritemst
startswithtisdirtdebug_printtmakedirs(R8R$RLRa((s1/usr/lib64/python2.7/distutils/command/install.pyR\"s	"cCs�|jsU|jd�|jjd�j}|jrU|t�krUtd��qUnx!|j�D]}|j|�qbW|j	r�|j
�n|jr|j�}|j
r�t|j
�}x/tt|��D]}|||||<q�Wn|jt|j|fd|j�nttjjtj�}ttjj|�}tjjtjj|j��}|jr�|j	oz|jr�||kr�tjd|j�ndS(NRJs"Can't install when cross-compilings'writing list of installed files to '%s's�modules installed to '%s', which is not in Python's module search path (sys.path) -- you'll have to change the search path yourself(R3trun_commandRUtget_command_objt	plat_nameR4R
Rtget_sub_commandsR�tcreate_path_fileR7tget_outputsR'R�txrangetexecuteRtmapRKRaRtRStnormcaseR+R2Rtdebug(R8t
build_plattcmd_nametoutputstroot_lentcountertsys_pathR+((s1/usr/lib64/python2.7/distutils/command/install.pytrun/s6	
	
			!		cCsctjj|j|jd�}|jrN|jt||jgfd|�n|j	d|�dS(Ns.pthscreating %sspath file '%s' not created(
RKRaRbR`R�R2R�RRcRM(R8tfilename((s1/usr/lib64/python2.7/distutils/command/install.pyR�]s		cCs�g}xV|j�D]H}|j|�}x0|j�D]"}||kr5|j|�q5q5WqW|jr�|jr�|jtjj|j	|jd��n|S(Ns.pth(
R�tget_finalized_commandR�tappendR�R2RKRaRbR`(R8R�R�tcmdR�((s1/usr/lib64/python2.7/distutils/command/install.pyR�jscCsCg}x6|j�D](}|j|�}|j|j��qW|S(N(R�R�textendt
get_inputs(R8tinputsR�R�((s1/usr/lib64/python2.7/distutils/command/install.pyR�{s
cCs|jj�p|jj�S(sRReturn true if the current distribution has any Python
        modules to install.(RUthas_pure_modulesthas_ext_modules(R8((s1/usr/lib64/python2.7/distutils/command/install.pythas_lib�scCs
|jj�S(N(RUthas_headers(R8((s1/usr/lib64/python2.7/distutils/command/install.pyR��scCs
|jj�S(N(RUthas_scripts(R8((s1/usr/lib64/python2.7/distutils/command/install.pyR��scCs
|jj�S(N(RUthas_data_files(R8((s1/usr/lib64/python2.7/distutils/command/install.pythas_data�sR+R*R,R-tinstall_egg_infocCstS(N(tTrue(R8((s1/usr/lib64/python2.7/distutils/command/install.pyt<lambda>�R�N(sprefix=Nsinstallation prefix(sexec-prefix=Ns.(Unix only) prefix for platform-specific files(shome=Ns+(Unix only) home directory to install under(s
install-base=Ns;base installation directory (instead of --prefix or --home)(sroot=Ns<install everything relative to this alternate root directory(sinstall-purelib=Ns;installation directory for pure Python module distributions(sinstall-platlib=Ns8installation directory for non-pure module distributions(sinstall-headers=Ns(installation directory for C/C++ headers(sinstall-scripts=Ns)installation directory for Python scripts(s
install-data=Ns%installation directory for data files(RRscompile .py to .pyc [default](s
no-compileNsdon't compile .py files(s	optimize=Rslalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0](RR s1force installation (overwrite any existing files)(s
skip-buildNs2skip rebuilding everything (for testing/debugging)(srecord=Ns3filename in which to record list of installed files(t__name__t
__module__tdescriptionR!R
Rktboolean_optionsRlR9RfRNRORPRsR�RZR[R^R_RdR\R�R�R�R�R�R�R�R�tsub_commands(((s1/usr/lib64/python2.7/distutils/command/install.pyR^s�
	
	M	�		+				
					"		
	.	
										(RRRRR( t__doc__t	distutilsRt__revision__RSRKRQttypestdistutils.coreRtdistutils.debugRtdistutils.sysconfigRtdistutils.errorsRtdistutils.file_utilRtdistutils.utilRRR	R
RtsiteRR
RTtWINDOWS_SCHEMERxRyR(((s1/usr/lib64/python2.7/distutils/command/install.pyt<module>s�$

command/install.pyo000064400000040662151702014350010367 0ustar00�
{fc@s�dZddlmZdZddlZddlZddlZddlTddlm	Z	ddl
mZddlm
Z
dd	lmZdd
lmZddlmZmZmZddlmZdd
lmZddlmZddlmZejdkr1idd6dd6dd6dd6dd6Zn)idd6dd6dd6dd6dd6Ziidd6dd6dd6dd6dd6d6idd6d d6d!d6dd6dd6d"6id#d6d#d6d$d6d%d6d&d6d'6ed(6id#d6d#d6d)d6d*d6d&d6d+6idd6dd6dd6dd6dd6d,6id#d6d#d6d$d6d%d6d&d6d-6Zd0Zd.e	fd/��YZdS(1sFdistutils.command.install

command/install_data.py000064400000005435151702014350011200 0ustar00"""distutils.command.install_data

Implements the Distutils 'install_data' command, for installing
platform-independent data files."""

# contributed by Bastian Kleineidam

__revision__ = "$Id$"

import os
from distutils.core import Command
from distutils.util import change_root, convert_path

class install_data(Command):

description = "install data files"

user_options = [
        ('install-dir=', 'd',
         "base directory for installing data files "
         "(default: installation base dir)"),
        ('root=', None,
         "install everything relative to this alternate root directory"),
        ('force', 'f', "force installation (overwrite existing files)"),
        ]

boolean_options = ['force']

def initialize_options(self):
        self.install_dir = None
        self.outfiles = []
        self.root = None
        self.force = 0
        self.data_files = self.distribution.data_files
        self.warn_dir = 1

def finalize_options(self):
        self.set_undefined_options('install',
                                   ('install_data', 'install_dir'),
                                   ('root', 'root'),
                                   ('force', 'force'),
                                  )

def run(self):
        self.mkpath(self.install_dir)
        for f in self.data_files:
            if isinstance(f, str):
                # it's a simple file, so copy it
                f = convert_path(f)
                if self.warn_dir:
                    self.warn("setup script did not provide a directory for "
                              "'%s' -- installing right in '%s'" %
                              (f, self.install_dir))
                (out, _) = self.copy_file(f, self.install_dir)
                self.outfiles.append(out)
            else:
                # it's a tuple with path to install to and a list of files
                dir = convert_path(f[0])
                if not os.path.isabs(dir):
                    dir = os.path.join(self.install_dir, dir)
                elif self.root:
                    dir = change_root(self.root, dir)
                self.mkpath(dir)

if f[1] == []:
                    # If there are no files listed, the user must be
                    # trying to create an empty directory, so add the
                    # directory to the list of output files.
                    self.outfiles.append(dir)
                else:
                    # Copy files, adding them to the list of output files.
                    for data in f[1]:
                        data = convert_path(data)
                        (out, _) = self.copy_file(data, dir)
                        self.outfiles.append(out)

def get_inputs(self):
        return self.data_files or []

def get_outputs(self):
        return self.outfiles
command/install_data.pyo000064400000006056151702014350011357 0ustar00�
{fc@sXdZdZddlZddlmZddlmZmZdefd��YZdS(s�distutils.command.install_data

Implements the Distutils 'install_data' command, for installing
platform-independent data files.s$Id$i����N(tCommand(tchange_roottconvert_pathtinstall_datacBsSeZdZdddgZdgZd	�Zd
�Zd�Zd�Z	d
�Z
RS(sinstall data filessinstall-dir=tdsIbase directory for installing data files (default: installation base dir)sroot=s<install everything relative to this alternate root directorytforcetfs-force installation (overwrite existing files)cCs@d|_g|_d|_d|_|jj|_d|_dS(Nii(tNonetinstall_dirtoutfilestrootRtdistributiont
data_filestwarn_dir(tself((s6/usr/lib64/python2.7/distutils/command/install_data.pytinitialize_optionss				cCs|jdddd�dS(	NtinstallRRR
R(RR(R
R
(RR(tset_undefined_options(R((s6/usr/lib64/python2.7/distutils/command/install_data.pytfinalize_options%s	cCsk|j|j�xT|jD]I}t|t�r�t|�}|jra|jd||jf�n|j||j�\}}|j	j
|�qt|d�}tjj
|�s�tjj|j|�}n|jr�t|j|�}n|j|�|dgkr|j	j
|�qxF|dD]:}t|�}|j||�\}}|j	j
|�q%WqWdS(NsMsetup script did not provide a directory for '%s' -- installing right in '%s'ii(tmkpathRRt
isinstancetstrRR
twarnt	copy_fileR	tappendtostpathtisabstjoinR
R(RRtoutt_tdirtdata((s6/usr/lib64/python2.7/distutils/command/install_data.pytrun,s*			
cCs
|jpgS(N(R(R((s6/usr/lib64/python2.7/distutils/command/install_data.pyt
get_inputsMscCs|jS(N(R	(R((s6/usr/lib64/python2.7/distutils/command/install_data.pytget_outputsPs(sinstall-dir=RsIbase directory for installing data files (default: installation base dir)N(sroot=Ns<install everything relative to this alternate root directory(RRs-force installation (overwrite existing files)(t__name__t
__module__tdescriptionRtuser_optionstboolean_optionsRRR!R"R#(((s6/usr/lib64/python2.7/distutils/command/install_data.pyRs					!	(	t__doc__t__revision__Rtdistutils.coreRtdistutils.utilRRR(((s6/usr/lib64/python2.7/distutils/command/install_data.pyt<module>s
command/install_egg_info.py000064400000005033151702014350012036 0ustar00"""distutils.command.install_egg_info

Implements the Distutils 'install_egg_info' command, for installing
a package's PKG-INFO metadata."""

from distutils.cmd import Command
from distutils import log, dir_util
import os, sys, re

class install_egg_info(Command):
    """Install an .egg-info file for the package"""

description = "Install package's PKG-INFO metadata as an .egg-info file"
    user_options = [
        ('install-dir=', 'd', "directory to install to"),
    ]

def initialize_options(self):
        self.install_dir = None

def finalize_options(self):
        self.set_undefined_options('install_lib',('install_dir','install_dir'))
        basename = "%s-%s-py%s.egg-info" % (
            to_filename(safe_name(self.distribution.get_name())),
            to_filename(safe_version(self.distribution.get_version())),
            sys.version[:3]
        )
        self.target = os.path.join(self.install_dir, basename)
        self.outputs = [self.target]

def run(self):
        target = self.target
        if os.path.isdir(target) and not os.path.islink(target):
            dir_util.remove_tree(target, dry_run=self.dry_run)
        elif os.path.exists(target):
            self.execute(os.unlink,(self.target,),"Removing "+target)
        elif not os.path.isdir(self.install_dir):
            self.execute(os.makedirs, (self.install_dir,),
                         "Creating "+self.install_dir)
        log.info("Writing %s", target)
        if not self.dry_run:
            f = open(target, 'w')
            self.distribution.metadata.write_pkg_file(f)
            f.close()

def get_outputs(self):
        return self.outputs

# The following routines are taken from setuptools' pkg_resources module and
# can be replaced by importing them from pkg_resources once it is included
# in the stdlib.

def safe_name(name):
    """Convert an arbitrary string to a standard distribution name

Any runs of non-alphanumeric/. characters are replaced with a single '-'.
    """
    return re.sub('[^A-Za-z0-9.]+', '-', name)

def safe_version(version):
    """Convert an arbitrary string to a standard version string

Spaces become dots, and all other non-alphanumeric characters become
    dashes, with runs of multiple dashes condensed to a single dash.
    """
    version = version.replace(' ','.')
    return re.sub('[^A-Za-z0-9.]+', '-', version)

def to_filename(name):
    """Convert a project or version name to its filename-escaped form

Any '-' characters are currently replaced with '_'.
    """
    return name.replace('-','_')
command/install_egg_info.pyo000064400000007240151702014350012217 0ustar00�
{fc@s�dZddlmZddlmZmZddlZddlZddlZdefd��YZ	d�Z
d�Zd	�ZdS(
s�distutils.command.install_egg_info

Any '-' characters are currently replaced with '_'.
    R0t_(R6(R3((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pyRIs(
R-t
distutils.cmdRt	distutilsRRRRR1RRRR(((s:/usr/lib64/python2.7/distutils/command/install_egg_info.pyt<module>s$,		
command/install_headers.py000064400000002502151702014350011672 0ustar00"""distutils.command.install_headers

Implements the Distutils 'install_headers' command, to install C/C++ header
files to the Python include directory."""

__revision__ = "$Id$"

from distutils.core import Command

# XXX force is never used
class install_headers(Command):

description = "install C/C++ header files"

user_options = [('install-dir=', 'd',
                     "directory to install header files to"),
                    ('force', 'f',
                     "force installation (overwrite existing files)"),
                   ]

boolean_options = ['force']

def initialize_options(self):
        self.install_dir = None
        self.force = 0
        self.outfiles = []

def finalize_options(self):
        self.set_undefined_options('install',
                                   ('install_headers', 'install_dir'),
                                   ('force', 'force'))

def run(self):
        headers = self.distribution.headers
        if not headers:
            return

self.mkpath(self.install_dir)
        for header in headers:
            (out, _) = self.copy_file(header, self.install_dir)
            self.outfiles.append(out)

def get_inputs(self):
        return self.distribution.headers or []

def get_outputs(self):
        return self.outfiles

# class install_headers
command/install_headers.pyo000064400000004317151702014350012057 0ustar00�
{fc@s6dZdZddlmZdefd��YZdS(s�distutils.command.install_headers

Implements the Distutils 'install_headers' command, to install C/C++ header
files to the Python include directory.s$Id$i����(tCommandtinstall_headerscBsPeZdZdd
gZdgZd�Zd�Zd	�Zd
�Zd�Z	RS(sinstall C/C++ header filessinstall-dir=tds$directory to install header files totforcetfs-force installation (overwrite existing files)cCsd|_d|_g|_dS(Ni(tNonetinstall_dirRtoutfiles(tself((s9/usr/lib64/python2.7/distutils/command/install_headers.pytinitialize_optionss		cCs|jddd�dS(NtinstallRRR(RR(RR(tset_undefined_options(R((s9/usr/lib64/python2.7/distutils/command/install_headers.pytfinalize_optionss	cCsf|jj}|sdS|j|j�x9|D]1}|j||j�\}}|jj|�q-WdS(N(tdistributiontheaderstmkpathRt	copy_fileRtappend(RRtheadertoutt_((s9/usr/lib64/python2.7/distutils/command/install_headers.pytrun#s
cCs|jjpgS(N(R
R(R((s9/usr/lib64/python2.7/distutils/command/install_headers.pyt
get_inputs-scCs|jS(N(R(R((s9/usr/lib64/python2.7/distutils/command/install_headers.pytget_outputs0s(sinstall-dir=Rs$directory to install header files to(RRs-force installation (overwrite existing files)(
t__name__t
__module__tdescriptiontuser_optionstboolean_optionsR	RRRR(((s9/usr/lib64/python2.7/distutils/command/install_headers.pyRs					
	N(t__doc__t__revision__tdistutils.coreRR(((s9/usr/lib64/python2.7/distutils/command/install_headers.pyt<module>scommand/install_lib.py000064400000020222151702014350011024 0ustar00"""distutils.command.install_lib

Implements the Distutils 'install_lib' command
(install all Python modules)."""

__revision__ = "$Id$"

import os
import sys

from distutils.core import Command
from distutils.errors import DistutilsOptionError

# Extension for Python source files.
if hasattr(os, 'extsep'):
    PYTHON_SOURCE_EXTENSION = os.extsep + "py"
else:
    PYTHON_SOURCE_EXTENSION = ".py"

class install_lib(Command):

description = "install all Python modules (extensions and pure Python)"

# The byte-compilation options are a tad confusing.  Here are the
    # possible scenarios:
    #   1) no compilation at all (--no-compile --no-optimize)
    #   2) compile .pyc only (--compile --no-optimize; default)
    #   3) compile .pyc and "level 1" .pyo (--compile --optimize)
    #   4) compile "level 1" .pyo only (--no-compile --optimize)
    #   5) compile .pyc and "level 2" .pyo (--compile --optimize-more)
    #   6) compile "level 2" .pyo only (--no-compile --optimize-more)
    #
    # The UI for this is two option, 'compile' and 'optimize'.
    # 'compile' is strictly boolean, and only decides whether to
    # generate .pyc files.  'optimize' is three-way (0, 1, or 2), and
    # decides both whether to generate .pyo files and what level of
    # optimization to use.

user_options = [
        ('install-dir=', 'd', "directory to install to"),
        ('build-dir=','b', "build directory (where to install from)"),
        ('force', 'f', "force installation (overwrite existing files)"),
        ('compile', 'c', "compile .py to .pyc [default]"),
        ('no-compile', None, "don't compile .py files"),
        ('optimize=', 'O',
         "also compile with optimization: -O1 for \"python -O\", "
         "-O2 for \"python -OO\", and -O0 to disable [default: -O0]"),
        ('skip-build', None, "skip the build steps"),
        ]

boolean_options = ['force', 'compile', 'skip-build']
    negative_opt = {'no-compile' : 'compile'}

def initialize_options(self):
        # let the 'install' command dictate our installation directory
        self.install_dir = None
        self.build_dir = None
        self.force = 0
        self.compile = None
        self.optimize = None
        self.skip_build = None

def finalize_options(self):
        # Get all the information we need to install pure Python modules
        # from the umbrella 'install' command -- build (source) directory,
        # install (target) directory, and whether to compile .py files.
        self.set_undefined_options('install',
                                   ('build_lib', 'build_dir'),
                                   ('install_lib', 'install_dir'),
                                   ('force', 'force'),
                                   ('compile', 'compile'),
                                   ('optimize', 'optimize'),
                                   ('skip_build', 'skip_build'),
                                  )

if self.compile is None:
            self.compile = 1
        if self.optimize is None:
            self.optimize = 0

if not isinstance(self.optimize, int):
            try:
                self.optimize = int(self.optimize)
                if self.optimize not in (0, 1, 2):
                    raise AssertionError
            except (ValueError, AssertionError):
                raise DistutilsOptionError, "optimize must be 0, 1, or 2"

def run(self):
        # Make sure we have built everything we need first
        self.build()

# Install everything: simply dump the entire contents of the build
        # directory to the installation directory (that's the beauty of
        # having a build directory!)
        outfiles = self.install()

# (Optionally) compile .py to .pyc
        if outfiles is not None and self.distribution.has_pure_modules():
            self.byte_compile(outfiles)

# -- Top-level worker functions ------------------------------------
    # (called from 'run()')

def build(self):
        if not self.skip_build:
            if self.distribution.has_pure_modules():
                self.run_command('build_py')
            if self.distribution.has_ext_modules():
                self.run_command('build_ext')

def install(self):
        if os.path.isdir(self.build_dir):
            outfiles = self.copy_tree(self.build_dir, self.install_dir)
        else:
            self.warn("'%s' does not exist -- no Python modules to install" %
                      self.build_dir)
            return
        return outfiles

def byte_compile(self, files):
        if sys.dont_write_bytecode:
            self.warn('byte-compiling is disabled, skipping.')
            return

from distutils.util import byte_compile

# Get the "--root" directory supplied to the "install" command,
        # and use it as a prefix to strip off the purported filename
        # encoded in bytecode files.  This is far from complete, but it
        # should at least generate usable bytecode in RPM distributions.
        install_root = self.get_finalized_command('install').root

if self.compile:
            byte_compile(files, optimize=0,
                         force=self.force, prefix=install_root,
                         dry_run=self.dry_run)
        if self.optimize > 0:
            byte_compile(files, optimize=self.optimize,
                         force=self.force, prefix=install_root,
                         verbose=self.verbose, dry_run=self.dry_run)

# -- Utility methods -----------------------------------------------

def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
        if not has_any:
            return []

build_cmd = self.get_finalized_command(build_cmd)
        build_files = build_cmd.get_outputs()
        build_dir = getattr(build_cmd, cmd_option)

prefix_len = len(build_dir) + len(os.sep)
        outputs = []
        for file in build_files:
            outputs.append(os.path.join(output_dir, file[prefix_len:]))

return outputs

def _bytecode_filenames(self, py_filenames):
        bytecode_files = []
        for py_file in py_filenames:
            # Since build_py handles package data installation, the
            # list of outputs can contain more than just .py files.
            # Make sure we only report bytecode for the .py files.
            ext = os.path.splitext(os.path.normcase(py_file))[1]
            if ext != PYTHON_SOURCE_EXTENSION:
                continue
            if self.compile:
                bytecode_files.append(py_file + "c")
            if self.optimize > 0:
                bytecode_files.append(py_file + "o")

return bytecode_files

# -- External interface --------------------------------------------
    # (called by outsiders)

def get_outputs(self):
        """Return the list of files that would be installed if this command
        were actually run.  Not affected by the "dry-run" flag or whether
        modules have actually been built yet.
        """
        pure_outputs = \
            self._mutate_outputs(self.distribution.has_pure_modules(),
                                 'build_py', 'build_lib',
                                 self.install_dir)
        if self.compile:
            bytecode_outputs = self._bytecode_filenames(pure_outputs)
        else:
            bytecode_outputs = []

ext_outputs = \
            self._mutate_outputs(self.distribution.has_ext_modules(),
                                 'build_ext', 'build_lib',
                                 self.install_dir)

return pure_outputs + bytecode_outputs + ext_outputs

def get_inputs(self):
        """Get the list of files that are input to this command, ie. the
        files that get installed as they are named in the build tree.
        The files in this list correspond one-to-one to the output
        filenames returned by 'get_outputs()'.
        """
        inputs = []

if self.distribution.has_pure_modules():
            build_py = self.get_finalized_command('build_py')
            inputs.extend(build_py.get_outputs())

if self.distribution.has_ext_modules():
            build_ext = self.get_finalized_command('build_ext')
            inputs.extend(build_ext.get_outputs())

return inputs
command/install_lib.pyo000064400000015031151702014350011205 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZeed�rcej	dZ
ndZ
d	efd
��YZdS(skdistutils.command.install_lib

Implements the Distutils 'install_lib' command
(install all Python modules).s$Id$i����N(tCommand(tDistutilsOptionErrortextseptpys.pytinstall_libc	Bs�eZdZddd d!d#d$d%gZdd
dgZid
d
6Zd�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd�ZRS(&s7install all Python modules (extensions and pure Python)sinstall-dir=tdsdirectory to install tos
build-dir=tbs'build directory (where to install from)tforcetfs-force installation (overwrite existing files)tcompiletcscompile .py to .pyc [default]s
no-compilesdon't compile .py filess	optimize=tOslalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0]s
skip-buildsskip the build stepscCs:d|_d|_d|_d|_d|_d|_dS(Ni(tNonetinstall_dirt	build_dirRR	toptimizet
skip_build(tself((s5/usr/lib64/python2.7/distutils/command/install_lib.pytinitialize_options7s					c	Cs�|jddddddd�|jdkr:d
|_n|jdkrUd|_nt|jt�s�y.t|j�|_|jdkr�t�nWq�ttfk
r�td
�q�XndS(Ntinstallt	build_libRRR
RR	RRiiisoptimize must be 0, 1, or 2(RR(RR
(RR(R	R	(RR(RR(iii(	tset_undefined_optionsR	RRt
isinstancetinttAssertionErrort
ValueErrorR(R((s5/usr/lib64/python2.7/distutils/command/install_lib.pytfinalize_options@s$	
cCsE|j�|j�}|dk	rA|jj�rA|j|�ndS(N(tbuildRRtdistributionthas_pure_modulestbyte_compile(Rtoutfiles((s5/usr/lib64/python2.7/distutils/command/install_lib.pytrunZs
cCsN|jsJ|jj�r(|jd�n|jj�rJ|jd�qJndS(Ntbuild_pyt	build_ext(RRRtrun_commandthas_ext_modules(R((s5/usr/lib64/python2.7/distutils/command/install_lib.pyRjs
	cCsLtjj|j�r0|j|j|j�}n|jd|j�dS|S(Ns3'%s' does not exist -- no Python modules to install(tostpathtisdirRt	copy_treeR
twarn(RR((s5/usr/lib64/python2.7/distutils/command/install_lib.pyRqs	cCs�tjr|jd�dSddlm}|jd�j}|jrp||ddd|jd|d	|j	�n|j
dkr�||d|j
d|jd|d
|jd	|j	�ndS(Ns%byte-compiling is disabled, skipping.i����(RRRiRtprefixtdry_runtverbose(tsystdont_write_bytecodeR)tdistutils.utilRtget_finalized_commandtrootR	RR+RR,(RtfilesRtinstall_root((s5/usr/lib64/python2.7/distutils/command/install_lib.pyRzs	
	
c
Cs�|s
gS|j|�}|j�}t||�}t|�ttj�}g}x.|D]&}	|jtjj||	|��qZW|S(N(	R0tget_outputstgetattrtlenR%tseptappendR&tjoin(
Rthas_anyt	build_cmdt
cmd_optiont
output_dirtbuild_filesRt
prefix_lentoutputstfile((s5/usr/lib64/python2.7/distutils/command/install_lib.pyt_mutate_outputs�s
$cCs�g}x�|D]z}tjjtjj|��d}|tkrGq
n|jrd|j|d�n|jdkr
|j|d�q
q
W|S(NiR
ito(R%R&tsplitexttnormcasetPYTHON_SOURCE_EXTENSIONR	R8R(Rtpy_filenamestbytecode_filestpy_filetext((s5/usr/lib64/python2.7/distutils/command/install_lib.pyt_bytecode_filenames�s
"	cCsu|j|jj�dd|j�}|jr?|j|�}ng}|j|jj�dd|j�}|||S(s�Return the list of files that would be installed if this command
        were actually run.  Not affected by the "dry-run" flag or whether
        modules have actually been built yet.
        R!RR"(RBRRR
R	RKR$(Rtpure_outputstbytecode_outputstext_outputs((s5/usr/lib64/python2.7/distutils/command/install_lib.pyR4�s	cCsrg}|jj�r:|jd�}|j|j��n|jj�rn|jd�}|j|j��n|S(s�Get the list of files that are input to this command, ie. the
        files that get installed as they are named in the build tree.
        The files in this list correspond one-to-one to the output
        filenames returned by 'get_outputs()'.
        R!R"(RRR0textendR4R$(RtinputsR!R"((s5/usr/lib64/python2.7/distutils/command/install_lib.pyt
get_inputs�s(sinstall-dir=Rsdirectory to install to(s
build-dir=Rs'build directory (where to install from)(RRs-force installation (overwrite existing files)(R	R
scompile .py to .pyc [default]N(s
no-compileNsdon't compile .py files(s	optimize=Rslalso compile with optimization: -O1 for "python -O", -O2 for "python -OO", and -O0 to disable [default: -O0](s
skip-buildNsskip the build steps(t__name__t
__module__tdescriptionRtuser_optionstboolean_optionstnegative_optRRR RRRRBRKR4RQ(((s5/usr/lib64/python2.7/distutils/command/install_lib.pyRs*	
											(t__doc__t__revision__R%R-tdistutils.coreRtdistutils.errorsRthasattrRRFR(((s5/usr/lib64/python2.7/distutils/command/install_lib.pyt<module>scommand/install_scripts.py000064400000004024151702014350011747 0ustar00"""distutils.command.install_scripts

Implements the Distutils 'install_scripts' command, for installing
Python scripts."""

# contributed by Bastian Kleineidam

__revision__ = "$Id$"

import os
from distutils.core import Command
from distutils import log
from stat import ST_MODE

class install_scripts (Command):

description = "install scripts (Python or otherwise)"

user_options = [
        ('install-dir=', 'd', "directory to install scripts to"),
        ('build-dir=','b', "build directory (where to install from)"),
        ('force', 'f', "force installation (overwrite existing files)"),
        ('skip-build', None, "skip the build steps"),
    ]

boolean_options = ['force', 'skip-build']

def initialize_options (self):
        self.install_dir = None
        self.force = 0
        self.build_dir = None
        self.skip_build = None

def finalize_options (self):
        self.set_undefined_options('build', ('build_scripts', 'build_dir'))
        self.set_undefined_options('install',
                                   ('install_scripts', 'install_dir'),
                                   ('force', 'force'),
                                   ('skip_build', 'skip_build'),
                                  )

def run (self):
        if not self.skip_build:
            self.run_command('build_scripts')
        self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
        if os.name == 'posix':
            # Set the executable bits (owner, group, and world) on
            # all the scripts we just installed.
            for file in self.get_outputs():
                if self.dry_run:
                    log.info("changing mode of %s", file)
                else:
                    mode = ((os.stat(file)[ST_MODE]) | 0555) & 07777
                    log.info("changing mode of %s to %o", file, mode)
                    os.chmod(file, mode)

def get_inputs (self):
        return self.distribution.scripts or []

def get_outputs(self):
        return self.outfiles or []

# class install_scripts
command/install_scripts.pyo000064400000005560151702014350012134 0ustar00�
{fc@sbdZdZddlZddlmZddlmZddlmZdefd��YZ	dS(	sudistutils.command.install_scripts

Implements the Distutils 'install_scripts' command, for installing
Python scripts.s$Id$i����N(tCommand(tlog(tST_MODEtinstall_scriptscBsYeZdZddddgZdd
gZd�Zd
�Zd�Zd�Z	d�Z
RS(s%install scripts (Python or otherwise)sinstall-dir=tdsdirectory to install scripts tos
build-dir=tbs'build directory (where to install from)tforcetfs-force installation (overwrite existing files)s
skip-buildsskip the build stepscCs(d|_d|_d|_d|_dS(Ni(tNonetinstall_dirRt	build_dirt
skip_build(tself((s9/usr/lib64/python2.7/distutils/command/install_scripts.pytinitialize_optionss			cCs*|jdd	�|jdd
dd�dS(
Ntbuildt
build_scriptsR
tinstallRR	RR(RR
(RR	(RR(RR(tset_undefined_options(R((s9/usr/lib64/python2.7/distutils/command/install_scripts.pytfinalize_options#s
	cCs�|js|jd�n|j|j|j�|_tjdkr�xq|j�D]`}|j	rrt
jd|�qPtj|�t
dBd@}t
jd||�tj||�qPWndS(NRtposixschanging mode of %simi�schanging mode of %s to %o(Rtrun_commandt	copy_treeR
R	toutfilestostnametget_outputstdry_runRtinfotstatRtchmod(Rtfiletmode((s9/usr/lib64/python2.7/distutils/command/install_scripts.pytrun+s		cCs|jjpgS(N(tdistributiontscripts(R((s9/usr/lib64/python2.7/distutils/command/install_scripts.pyt
get_inputs:scCs
|jpgS(N(R(R((s9/usr/lib64/python2.7/distutils/command/install_scripts.pyR=s(sinstall-dir=Rsdirectory to install scripts to(s
build-dir=Rs'build directory (where to install from)(RRs-force installation (overwrite existing files)N(s
skip-buildNsskip the build steps(t__name__t
__module__tdescriptionRtuser_optionstboolean_optionsR
RR R#R(((s9/usr/lib64/python2.7/distutils/command/install_scripts.pyRs					(
t__doc__t__revision__Rtdistutils.coreRt	distutilsRRRR(((s9/usr/lib64/python2.7/distutils/command/install_scripts.pyt<module>scommand/register.py000064400000027077151702014350010373 0ustar00"""distutils.command.register

Implements the Distutils 'register' command (register with the repository).
"""

# created 2002/10/21, Richard Jones

__revision__ = "$Id$"

import urllib2
import getpass
import urlparse
from warnings import warn

from distutils.core import PyPIRCCommand
from distutils import log

class register(PyPIRCCommand):

description = ("register the distribution with the Python package index")
    user_options = PyPIRCCommand.user_options + [
        ('list-classifiers', None,
         'list the valid Trove classifiers'),
        ('strict', None ,
         'Will stop the registering if the meta-data are not fully compliant')
        ]
    boolean_options = PyPIRCCommand.boolean_options + [
        'verify', 'list-classifiers', 'strict']

sub_commands = [('check', lambda self: True)]

def initialize_options(self):
        PyPIRCCommand.initialize_options(self)
        self.list_classifiers = 0
        self.strict = 0

def finalize_options(self):
        PyPIRCCommand.finalize_options(self)
        # setting options for the `check` subcommand
        check_options = {'strict': ('register', self.strict),
                         'restructuredtext': ('register', 1)}
        self.distribution.command_options['check'] = check_options

def run(self):
        self.finalize_options()
        self._set_config()

# Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

if self.dry_run:
            self.verify_metadata()
        elif self.list_classifiers:
            self.classifiers()
        else:
            self.send_metadata()

def check_metadata(self):
        """Deprecated API."""
        warn("distutils.command.register.check_metadata is deprecated, \
              use the check command instead", PendingDeprecationWarning)
        check = self.distribution.get_command_obj('check')
        check.ensure_finalized()
        check.strict = self.strict
        check.restructuredtext = 1
        check.run()

def _set_config(self):
        ''' Reads the configuration file and set attributes.
        '''
        config = self._read_pypirc()
        if config != {}:
            self.username = config['username']
            self.password = config['password']
            self.repository = config['repository']
            self.realm = config['realm']
            self.has_config = True
        else:
            if self.repository not in ('pypi', self.DEFAULT_REPOSITORY):
                raise ValueError('%s not found in .pypirc' % self.repository)
            if self.repository == 'pypi':
                self.repository = self.DEFAULT_REPOSITORY
            self.has_config = False

def classifiers(self):
        ''' Fetch the list of classifiers from the server.
        '''
        response = urllib2.urlopen(self.repository+'?:action=list_classifiers')
        log.info(response.read())

def verify_metadata(self):
        ''' Send the metadata to the package index server to be checked.
        '''
        # send the info to the server and report the result
        (code, result) = self.post_to_server(self.build_post_data('verify'))
        log.info('Server response (%s): %s' % (code, result))

def send_metadata(self):
        ''' Send the metadata to the package index server.

Well, do the following:
            1. figure who the user is, and then
            2. send the data as a Basic auth'ed POST.

First we try to read the username/password from $HOME/.pypirc,
            which is a ConfigParser-formatted file with a section
            [distutils] containing username and password entries (both
            in clear text). Eg:

[distutils]
                index-servers =
                    pypi

[pypi]
                username: fred
                password: sekrit

Otherwise, to figure who the user is, we offer the user three
            choices:

1. use existing login,
             2. register as a new user, or
             3. set the password to a random string and email the user.

'''
        # see if we can short-cut and get the username/password from the
        # config
        if self.has_config:
            choice = '1'
            username = self.username
            password = self.password
        else:
            choice = 'x'
            username = password = ''

# get the user's login info
        choices = '1 2 3 4'.split()
        while choice not in choices:
            self.announce('''\
We need to know who you are, so please choose either:
 1. use your existing login,
 2. register as a new user,
 3. have the server generate a new password for you (and email it to you), or
 4. quit
Your selection [default 1]: ''', log.INFO)

choice = raw_input()
            if not choice:
                choice = '1'
            elif choice not in choices:
                print 'Please choose one of the four options!'

if choice == '1':
            # get the username and password
            while not username:
                username = raw_input('Username: ')
            while not password:
                password = getpass.getpass('Password: ')

# set up the authentication
            auth = urllib2.HTTPPasswordMgr()
            host = urlparse.urlparse(self.repository)[1]
            auth.add_password(self.realm, host, username, password)
            # send the info to the server and report the result
            code, result = self.post_to_server(self.build_post_data('submit'),
                auth)
            self.announce('Server response (%s): %s' % (code, result),
                          log.INFO)

# possibly save the login
            if code == 200:
                if self.has_config:
                    # sharing the password in the distribution instance
                    # so the upload command can reuse it
                    self.distribution.password = password
                else:
                    self.announce(('I can store your PyPI login so future '
                                   'submissions will be faster.'), log.INFO)
                    self.announce('(the login will be stored in %s)' % \
                                  self._get_rc_file(), log.INFO)
                    choice = 'X'
                    while choice.lower() not in 'yn':
                        choice = raw_input('Save your login (y/N)?')
                        if not choice:
                            choice = 'n'
                    if choice.lower() == 'y':
                        self._store_pypirc(username, password)

elif choice == '2':
            data = {':action': 'user'}
            data['name'] = data['password'] = data['email'] = ''
            data['confirm'] = None
            while not data['name']:
                data['name'] = raw_input('Username: ')
            while data['password'] != data['confirm']:
                while not data['password']:
                    data['password'] = getpass.getpass('Password: ')
                while not data['confirm']:
                    data['confirm'] = getpass.getpass(' Confirm: ')
                if data['password'] != data['confirm']:
                    data['password'] = ''
                    data['confirm'] = None
                    print "Password and confirm don't match!"
            while not data['email']:
                data['email'] = raw_input('   EMail: ')
            code, result = self.post_to_server(data)
            if code != 200:
                log.info('Server response (%s): %s' % (code, result))
            else:
                log.info('You will receive an email shortly.')
                log.info(('Follow the instructions in it to '
                          'complete registration.'))
        elif choice == '3':
            data = {':action': 'password_reset'}
            data['email'] = ''
            while not data['email']:
                data['email'] = raw_input('Your email address: ')
            code, result = self.post_to_server(data)
            log.info('Server response (%s): %s' % (code, result))

def build_post_data(self, action):
        # figure the data to send - the metadata plus some additional
        # information used by the package server
        meta = self.distribution.metadata
        data = {
            ':action': action,
            'metadata_version' : '1.0',
            'name': meta.get_name(),
            'version': meta.get_version(),
            'summary': meta.get_description(),
            'home_page': meta.get_url(),
            'author': meta.get_contact(),
            'author_email': meta.get_contact_email(),
            'license': meta.get_licence(),
            'description': meta.get_long_description(),
            'keywords': meta.get_keywords(),
            'platform': meta.get_platforms(),
            'classifiers': meta.get_classifiers(),
            'download_url': meta.get_download_url(),
            # PEP 314
            'provides': meta.get_provides(),
            'requires': meta.get_requires(),
            'obsoletes': meta.get_obsoletes(),
        }
        if data['provides'] or data['requires'] or data['obsoletes']:
            data['metadata_version'] = '1.1'
        return data

def post_to_server(self, data, auth=None):
        ''' Post a query to the server, and return a string response.
        '''
        if 'name' in data:
            self.announce('Registering %s to %s' % (data['name'],
                                                   self.repository),
                                                   log.INFO)
        # Build up the MIME payload for the urllib2 POST data
        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
        sep_boundary = '\n--' + boundary
        end_boundary = sep_boundary + '--'
        chunks = []
        for key, value in data.items():
            # handle multiple entries for the same name
            if type(value) not in (type([]), type( () )):
                value = [value]
            for value in value:
                chunks.append(sep_boundary)
                chunks.append('\nContent-Disposition: form-data; name="%s"'%key)
                chunks.append("\n\n")
                chunks.append(value)
                if value and value[-1] == '\r':
                    chunks.append('\n')  # write an extra newline (lurve Macs)
        chunks.append(end_boundary)
        chunks.append("\n")

# chunks may be bytes (str) or unicode objects that we need to encode
        body = []
        for chunk in chunks:
            if isinstance(chunk, unicode):
                body.append(chunk.encode('utf-8'))
            else:
                body.append(chunk)

body = ''.join(body)

# build the Request
        headers = {
            'Content-type': 'multipart/form-data; boundary=%s; charset=utf-8'%boundary,
            'Content-length': str(len(body))
        }
        req = urllib2.Request(self.repository, body, headers)

# handle HTTP and include the Basic Auth handler
        opener = urllib2.build_opener(
            urllib2.HTTPBasicAuthHandler(password_mgr=auth)
        )
        data = ''
        try:
            result = opener.open(req)
        except urllib2.HTTPError, e:
            if self.show_response:
                data = e.fp.read()
            result = e.code, e.msg
        except urllib2.URLError, e:
            result = 500, str(e)
        else:
            if self.show_response:
                data = result.read()
            result = 200, 'OK'
        if self.show_response:
            dashes = '-' * 75
            self.announce('%s%s%s' % (dashes, data, dashes))

return result
command/register.pyc000064400000023740151702014350010527 0ustar00�
{fc@szdZdZddlZddlZddlZddlmZddlmZddl	m
Z
defd��YZdS(	shdistutils.command.register

Implements the Distutils 'register' command (register with the repository).
s$Id$i����N(twarn(t
PyPIRCCommand(tlogtregistercBs�eZdZejddgZejdddgZdd�fgZd�Zd	�Z	d
�Z
d�Zd�Zd
�Z
d�Zd�Zd�Zdd�ZRS(s7register the distribution with the Python package indexslist-classifierss list the valid Trove classifierststrictsBWill stop the registering if the meta-data are not fully complianttverifytcheckcCstS(N(tTrue(tself((s2/usr/lib64/python2.7/distutils/command/register.pyt<lambda>tcCs#tj|�d|_d|_dS(Ni(Rtinitialize_optionstlist_classifiersR(R((s2/usr/lib64/python2.7/distutils/command/register.pyR s
	cCs>tj|�id|jfd6dd6}||jjd<dS(NRRitrestructuredtextR(Ri(Rtfinalize_optionsRtdistributiontcommand_options(Rt
check_options((s2/usr/lib64/python2.7/distutils/command/register.pyR%s

cCsr|j�|j�x!|j�D]}|j|�q!W|jrN|j�n |jrd|j�n
|j�dS(N(	Rt_set_configtget_sub_commandstrun_commandtdry_runtverify_metadataRtclassifierst
send_metadata(Rtcmd_name((s2/usr/lib64/python2.7/distutils/command/register.pytrun,s

cCsLtdt�|jjd�}|j�|j|_d|_|j�dS(sDeprecated API.sddistutils.command.register.check_metadata is deprecated,               use the check command insteadRiN(RtPendingDeprecationWarningRtget_command_objtensure_finalizedRR
R(RR((s2/usr/lib64/python2.7/distutils/command/register.pytcheck_metadata;s

cCs�|j�}|ikrX|d|_|d|_|d|_|d|_t|_nU|jd|jfkr�td|j��n|jdkr�|j|_nt	|_dS(s: Reads the configuration file and set attributes.
        tusernametpasswordt
repositorytrealmtpypis%s not found in .pypircN(
t_read_pypircRR R!R"Rt
has_configtDEFAULT_REPOSITORYt
ValueErrortFalse(Rtconfig((s2/usr/lib64/python2.7/distutils/command/register.pyREs

cCs-tj|jd�}tj|j��dS(s8 Fetch the list of classifiers from the server.
        s?:action=list_classifiersN(turllib2turlopenR!Rtinfotread(Rtresponse((s2/usr/lib64/python2.7/distutils/command/register.pyRVscCs9|j|jd��\}}tjd||f�dS(sF Send the metadata to the package index server to be checked.
        RsServer response (%s): %sN(tpost_to_servertbuild_post_dataRR,(Rtcodetresult((s2/usr/lib64/python2.7/distutils/command/register.pyR\sc
Cs�|jr$d}|j}|j}nd}d}}dj�}xO||kr�|jdtj�t�}|szd}qC||krCdGHqCqCW|dkrx|s�td�}q�Wx|s�tjd�}q�Wt	j
�}tj|j�d	}|j
|j|||�|j|jd
�|�\}}|jd||ftj�|dkr�|jrp||j_q|jd
tj�|jd|j�tj�d}x1|j�dkr�td�}|s�d}q�q�W|j�dkr|j||�qq�n�|dkroidd6}	d|	d<|	d<|	d<d#|	d<x|	dsbtd�|	d<qEWx�|	d|	dkr�x!|	ds�tjd�|	d<q}Wx!|	ds�tjd�|	d<q�W|	d|	dkrfd|	d<d#|	d<dGHqfqfWx|	dstd�|	d<q�W|j|	�\}}|dkrRtjd||f�q�tjd�tjd�ns|d kr�id!d6}	d|	d<x|	ds�td"�|	d<q�W|j|	�\}}tjd||f�nd#S($s_ Send the metadata to the package index server.

Well, do the following:
            1. figure who the user is, and then
            2. send the data as a Basic auth'ed POST.

[distutils]
                index-servers =
                    pypi

[pypi]
                username: fred
                password: sekrit

Otherwise, to figure who the user is, we offer the user three
            choices:

1. use existing login,
             2. register as a new user, or
             3. set the password to a random string and email the user.

t1txR
s1 2 3 4s�We need to know who you are, so please choose either:
 1. use your existing login,
 2. register as a new user,
 3. have the server generate a new password for you (and email it to you), or
 4. quit
Your selection [default 1]: s&Please choose one of the four options!s
Username: s
Password: itsubmitsServer response (%s): %si�sAI can store your PyPI login so future submissions will be faster.s (the login will be stored in %s)tXtynsSave your login (y/N)?tntyt2tusers:actiontnameR temailtconfirms
 Confirm: s!Password and confirm don't match!s
   EMail: s"You will receive an email shortly.s7Follow the instructions in it to complete registration.t3tpassword_resetsYour email address: N(R%RR tsplittannounceRtINFOt	raw_inputtgetpassR*tHTTPPasswordMgrturlparseR!tadd_passwordR"R/R0Rt_get_rc_filetlowert
_store_pypirctNoneR,(
RtchoiceRR tchoicestauththostR1R2tdata((s2/usr/lib64/python2.7/distutils/command/register.pyRds�

cCs|jj}i|d6dd6|j�d6|j�d6|j�d6|j�d6|j�d6|j�d	6|j�d
6|j	�d6|j
�d6|j�d
6|j�d6|j
�d6|j�d6|j�d6|j�d6}|ds|ds|drd|d<n|S(Ns:actions1.0tmetadata_versionR<tversiontsummaryt	home_pagetauthortauthor_emailtlicensetdescriptiontkeywordstplatformRtdownload_urltprovidestrequirest	obsoletess1.1(Rtmetadatatget_nametget_versiontget_descriptiontget_urltget_contacttget_contact_emailtget_licencetget_long_descriptiontget_keywordst
get_platformstget_classifierstget_download_urltget_providestget_requirest
get_obsoletes(RtactiontmetaRQ((s2/usr/lib64/python2.7/distutils/command/register.pyR0�s,

cCs�d|kr3|jd|d|jftj�nd}d|}|d}g}x�|j�D]�\}}t|�tg�td�fkr�|g}nxl|D]d}|j|�|jd|�|jd�|j|�|r�|dd	kr�|jd
�q�q�Wq`W|j|�|jd
�g}	xC|D];}
t|
t�rd|	j|
j	d��q6|	j|
�q6Wdj
|	�}	id
|d6tt|	��d6}t
j|j|	|�}t
jt
jd|��}
d}y|
j|�}Wnjt
jk
r9}|jr$|jj�}n|j|jf}nFt
jk
r`}dt|�f}nX|jry|j�}nd}|jr�dd}|jd|||f�n|S(sC Post a query to the server, and return a string response.
        R<sRegistering %s to %ss3--------------GHSKFJDLGDS7543FJKLFHRE75642756743254s
--s--s*
Content-Disposition: form-data; name="%s"s

i����s
s
sutf-8R
s/multipart/form-data; boundary=%s; charset=utf-8sContent-typesContent-lengthtpassword_mgri�i�tOKt-iKs%s%s%s((i�Rs(RBR!RRCtitemsttypetappendt
isinstancetunicodetencodetjointstrtlenR*tRequesttbuild_openertHTTPBasicAuthHandlertopent	HTTPErrort
show_responsetfpR-R1tmsgtURLError(RRQROtboundarytsep_boundarytend_boundarytchunkstkeytvaluetbodytchunktheaderstreqtopenerR2tetdashes((s2/usr/lib64/python2.7/distutils/command/register.pyR/�s`

N(slist-classifiersNs list the valid Trove classifiers(RNsBWill stop the registering if the meta-data are not fully compliant(t__name__t
__module__RYRtuser_optionsRLtboolean_optionstsub_commandsRRRRRRRRR0R/(((s2/usr/lib64/python2.7/distutils/command/register.pyRs&
				
				{	(t__doc__t__revision__R*RERGtwarningsRtdistutils.coreRt	distutilsRR(((s2/usr/lib64/python2.7/distutils/command/register.pyt<module>scommand/register.pyo000064400000023740151702014350010543 0ustar00�
{fc@szdZdZddlZddlZddlZddlmZddlmZddl	m
Z
defd��YZdS(	shdistutils.command.register

Well, do the following:
            1. figure who the user is, and then
            2. send the data as a Basic auth'ed POST.

[distutils]
                index-servers =
                    pypi

[pypi]
                username: fred
                password: sekrit

Otherwise, to figure who the user is, we offer the user three
            choices:

1. use existing login,
             2. register as a new user, or
             3. set the password to a random string and email the user.

N(slist-classifiersNs list the valid Trove classifiers(RNsBWill stop the registering if the meta-data are not fully compliant(t__name__t
__module__RYRtuser_optionsRLtboolean_optionstsub_commandsRRRRRRRRR0R/(((s2/usr/lib64/python2.7/distutils/command/register.pyRs&
				
				{	(t__doc__t__revision__R*RERGtwarningsRtdistutils.coreRt	distutilsRR(((s2/usr/lib64/python2.7/distutils/command/register.pyt<module>scommand/sdist.py000064400000044175151702014350007673 0ustar00"""distutils.command.sdist

Implements the Distutils 'sdist' command (create a source distribution)."""

__revision__ = "$Id$"

import os
import string
import sys
from glob import glob
from warnings import warn

from distutils.core import Command
from distutils import dir_util, dep_util, file_util, archive_util
from distutils.text_file import TextFile
from distutils.errors import (DistutilsPlatformError, DistutilsOptionError,
                              DistutilsTemplateError)
from distutils.filelist import FileList
from distutils import log
from distutils.util import convert_path

def show_formats():
    """Print all possible values for the 'formats' option (used by
    the "--help-formats" command-line option).
    """
    from distutils.fancy_getopt import FancyGetopt
    from distutils.archive_util import ARCHIVE_FORMATS
    formats = []
    for format in ARCHIVE_FORMATS.keys():
        formats.append(("formats=" + format, None,
                        ARCHIVE_FORMATS[format][2]))
    formats.sort()
    FancyGetopt(formats).print_help(
        "List of available source distribution formats:")

class sdist(Command):

description = "create a source distribution (tarball, zip file, etc.)"

def checking_metadata(self):
        """Callable used for the check sub-command.

Placed here so user_options can view it"""
        return self.metadata_check

user_options = [
        ('template=', 't',
         "name of manifest template file [default: MANIFEST.in]"),
        ('manifest=', 'm',
         "name of manifest file [default: MANIFEST]"),
        ('use-defaults', None,
         "include the default file set in the manifest "
         "[default; disable with --no-defaults]"),
        ('no-defaults', None,
         "don't include the default file set"),
        ('prune', None,
         "specifically exclude files/directories that should not be "
         "distributed (build tree, RCS/CVS dirs, etc.) "
         "[default; disable with --no-prune]"),
        ('no-prune', None,
         "don't automatically exclude anything"),
        ('manifest-only', 'o',
         "just regenerate the manifest and then stop "
         "(implies --force-manifest)"),
        ('force-manifest', 'f',
         "forcibly regenerate the manifest and carry on as usual. "
         "Deprecated: now the manifest is always regenerated."),
        ('formats=', None,
         "formats for source distribution (comma-separated list)"),
        ('keep-temp', 'k',
         "keep the distribution tree around after creating " +
         "archive file(s)"),
        ('dist-dir=', 'd',
         "directory to put the source distribution archive(s) in "
         "[default: dist]"),
        ('metadata-check', None,
         "Ensure that all required elements of meta-data "
         "are supplied. Warn if any missing. [default]"),
        ('owner=', 'u',
         "Owner name used when creating a tar file [default: current user]"),
        ('group=', 'g',
         "Group name used when creating a tar file [default: current group]"),
        ]

boolean_options = ['use-defaults', 'prune',
                       'manifest-only', 'force-manifest',
                       'keep-temp', 'metadata-check']

help_options = [
        ('help-formats', None,
         "list available distribution formats", show_formats),
        ]

negative_opt = {'no-defaults': 'use-defaults',
                    'no-prune': 'prune' }

default_format = {'posix': 'gztar',
                      'nt': 'zip' }

sub_commands = [('check', checking_metadata)]

def initialize_options(self):
        # 'template' and 'manifest' are, respectively, the names of
        # the manifest template and manifest file.
        self.template = None
        self.manifest = None

# 'use_defaults': if true, we will include the default file set
        # in the manifest
        self.use_defaults = 1
        self.prune = 1

self.manifest_only = 0
        self.force_manifest = 0

self.formats = None
        self.keep_temp = 0
        self.dist_dir = None

self.archive_files = None
        self.metadata_check = 1
        self.owner = None
        self.group = None

def finalize_options(self):
        if self.manifest is None:
            self.manifest = "MANIFEST"
        if self.template is None:
            self.template = "MANIFEST.in"

self.ensure_string_list('formats')
        if self.formats is None:
            try:
                self.formats = [self.default_format[os.name]]
            except KeyError:
                raise DistutilsPlatformError, \
                      "don't know how to create source distributions " + \
                      "on platform %s" % os.name

bad_format = archive_util.check_archive_formats(self.formats)
        if bad_format:
            raise DistutilsOptionError, \
                  "unknown archive format '%s'" % bad_format

if self.dist_dir is None:
            self.dist_dir = "dist"

def run(self):
        # 'filelist' contains the list of files that will make up the
        # manifest
        self.filelist = FileList()

# Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

# Do whatever it takes to get the list of files to process
        # (process the manifest template, read an existing manifest,
        # whatever).  File list is accumulated in 'self.filelist'.
        self.get_file_list()

# If user just wanted us to regenerate the manifest, stop now.
        if self.manifest_only:
            return

# Otherwise, go ahead and create the source distribution tarball,
        # or zipfile, or whatever.
        self.make_distribution()

def check_metadata(self):
        """Deprecated API."""
        warn("distutils.command.sdist.check_metadata is deprecated, \
              use the check command instead", PendingDeprecationWarning)
        check = self.distribution.get_command_obj('check')
        check.ensure_finalized()
        check.run()

def get_file_list(self):
        """Figure out the list of files to include in the source
        distribution, and put it in 'self.filelist'.  This might involve
        reading the manifest template (and writing the manifest), or just
        reading the manifest, or just using the default file set -- it all
        depends on the user's options.
        """
        # new behavior when using a template:
        # the file list is recalculated every time because
        # even if MANIFEST.in or setup.py are not changed
        # the user might have added some files in the tree that
        # need to be included.
        #
        #  This makes --force the default and only behavior with templates.
        template_exists = os.path.isfile(self.template)
        if not template_exists and self._manifest_is_not_generated():
            self.read_manifest()
            self.filelist.sort()
            self.filelist.remove_duplicates()
            return

if not template_exists:
            self.warn(("manifest template '%s' does not exist " +
                        "(using default file list)") %
                        self.template)
        self.filelist.findall()

if self.use_defaults:
            self.add_defaults()

if template_exists:
            self.read_template()

if self.prune:
            self.prune_file_list()

self.filelist.sort()
        self.filelist.remove_duplicates()
        self.write_manifest()

def add_defaults(self):
        """Add all the default files to self.filelist:
          - README or README.txt
          - setup.py
          - test/test*.py
          - all pure Python modules mentioned in setup script
          - all files pointed by package_data (build_py)
          - all files defined in data_files.
          - all files defined as scripts.
          - all C sources listed as part of extensions or C libraries
            in the setup script (doesn't catch C headers!)
        Warns if (README or README.txt) or setup.py are missing; everything
        else is optional.
        """

standards = [('README', 'README.txt'), self.distribution.script_name]
        for fn in standards:
            if isinstance(fn, tuple):
                alts = fn
                got_it = 0
                for fn in alts:
                    if os.path.exists(fn):
                        got_it = 1
                        self.filelist.append(fn)
                        break

if not got_it:
                    self.warn("standard file not found: should have one of " +
                              string.join(alts, ', '))
            else:
                if os.path.exists(fn):
                    self.filelist.append(fn)
                else:
                    self.warn("standard file '%s' not found" % fn)

optional = ['test/test*.py', 'setup.cfg']
        for pattern in optional:
            files = filter(os.path.isfile, glob(pattern))
            if files:
                self.filelist.extend(files)

# build_py is used to get:
        #  - python modules
        #  - files defined in package_data
        build_py = self.get_finalized_command('build_py')

# getting python files
        if self.distribution.has_pure_modules():
            self.filelist.extend(build_py.get_source_files())

# getting package_data files
        # (computed in build_py.data_files by build_py.finalize_options)
        for pkg, src_dir, build_dir, filenames in build_py.data_files:
            for filename in filenames:
                self.filelist.append(os.path.join(src_dir, filename))

# getting distribution.data_files
        if self.distribution.has_data_files():
            for item in self.distribution.data_files:
                if isinstance(item, str): # plain file
                    item = convert_path(item)
                    if os.path.isfile(item):
                        self.filelist.append(item)
                else:    # a (dirname, filenames) tuple
                    dirname, filenames = item
                    for f in filenames:
                        f = convert_path(f)
                        if os.path.isfile(f):
                            self.filelist.append(f)

if self.distribution.has_ext_modules():
            build_ext = self.get_finalized_command('build_ext')
            self.filelist.extend(build_ext.get_source_files())

if self.distribution.has_c_libraries():
            build_clib = self.get_finalized_command('build_clib')
            self.filelist.extend(build_clib.get_source_files())

if self.distribution.has_scripts():
            build_scripts = self.get_finalized_command('build_scripts')
            self.filelist.extend(build_scripts.get_source_files())

def read_template(self):
        """Read and parse manifest template file named by self.template.

(usually "MANIFEST.in") The parsing and processing is done by
        'self.filelist', which updates itself accordingly.
        """
        log.info("reading manifest template '%s'", self.template)
        template = TextFile(self.template,
                            strip_comments=1,
                            skip_blanks=1,
                            join_lines=1,
                            lstrip_ws=1,
                            rstrip_ws=1,
                            collapse_join=1)

try:
            while 1:
                line = template.readline()
                if line is None:            # end of file
                    break

try:
                    self.filelist.process_template_line(line)
                # the call above can raise a DistutilsTemplateError for
                # malformed lines, or a ValueError from the lower-level
                # convert_path function
                except (DistutilsTemplateError, ValueError) as msg:
                    self.warn("%s, line %d: %s" % (template.filename,
                                                   template.current_line,
                                                   msg))
        finally:
            template.close()

def prune_file_list(self):
        """Prune off branches that might slip into the file list as created
        by 'read_template()', but really don't belong there:
          * the build tree (typically "build")
          * the release tree itself (only an issue if we ran "sdist"
            previously with --keep-temp, or it aborted)
          * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
        """
        build = self.get_finalized_command('build')
        base_dir = self.distribution.get_fullname()

self.filelist.exclude_pattern(None, prefix=build.build_base)
        self.filelist.exclude_pattern(None, prefix=base_dir)

# pruning out vcs directories
        # both separators are used under win32
        if sys.platform == 'win32':
            seps = r'/|\\'
        else:
            seps = '/'

vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr',
                    '_darcs']
        vcs_ptrn = r'(^|%s)(%s)(%s).*' % (seps, '|'.join(vcs_dirs), seps)
        self.filelist.exclude_pattern(vcs_ptrn, is_regex=1)

def write_manifest(self):
        """Write the file list in 'self.filelist' (presumably as filled in
        by 'add_defaults()' and 'read_template()') to the manifest file
        named by 'self.manifest'.
        """
        if self._manifest_is_not_generated():
            log.info("not writing to manually maintained "
                     "manifest file '%s'" % self.manifest)
            return

content = self.filelist.files[:]
        content.insert(0, '# file GENERATED by distutils, do NOT edit')
        self.execute(file_util.write_file, (self.manifest, content),
                     "writing manifest file '%s'" % self.manifest)

def _manifest_is_not_generated(self):
        # check for special comment used in 2.7.1 and higher
        if not os.path.isfile(self.manifest):
            return False

fp = open(self.manifest, 'rU')
        try:
            first_line = fp.readline()
        finally:
            fp.close()
        return first_line != '# file GENERATED by distutils, do NOT edit\n'

def read_manifest(self):
        """Read the manifest file (named by 'self.manifest') and use it to
        fill in 'self.filelist', the list of files to include in the source
        distribution.
        """
        log.info("reading manifest file '%s'", self.manifest)
        manifest = open(self.manifest)
        for line in manifest:
            # ignore comments and blank lines
            line = line.strip()
            if line.startswith('#') or not line:
                continue
            self.filelist.append(line)
        manifest.close()

def make_release_tree(self, base_dir, files):
        """Create the directory tree that will become the source
        distribution archive.  All directories implied by the filenames in
        'files' are created under 'base_dir', and then we hard link or copy
        (if hard linking is unavailable) those files into place.
        Essentially, this duplicates the developer's source tree, but in a
        directory named after the distribution, containing only the files
        to be distributed.
        """
        # Create all the directories under 'base_dir' necessary to
        # put 'files' there; the 'mkpath()' is just so we don't die
        # if the manifest happens to be empty.
        self.mkpath(base_dir)
        dir_util.create_tree(base_dir, files, dry_run=self.dry_run)

# And walk over the list of files, either making a hard link (if
        # os.link exists) to each one that doesn't already exist in its
        # corresponding location under 'base_dir', or copying each file
        # that's out-of-date in 'base_dir'.  (Usually, all files will be
        # out-of-date, because by default we blow away 'base_dir' when
        # we're done making the distribution archives.)

if hasattr(os, 'link'):        # can make hard links on this system
            link = 'hard'
            msg = "making hard links in %s..." % base_dir
        else:                           # nope, have to copy
            link = None
            msg = "copying files to %s..." % base_dir

if not files:
            log.warn("no files to distribute -- empty manifest?")
        else:
            log.info(msg)
        for file in files:
            if not os.path.isfile(file):
                log.warn("'%s' not a regular file -- skipping" % file)
            else:
                dest = os.path.join(base_dir, file)
                self.copy_file(file, dest, link=link)

self.distribution.metadata.write_pkg_info(base_dir)

def make_distribution(self):
        """Create the source distribution(s).  First, we create the release
        tree with 'make_release_tree()'; then, we create all required
        archive files (according to 'self.formats') from the release tree.
        Finally, we clean up by blowing away the release tree (unless
        'self.keep_temp' is true).  The list of archive files created is
        stored so it can be retrieved later by 'get_archive_files()'.
        """
        # Don't warn about missing meta-data here -- should be (and is!)
        # done elsewhere.
        base_dir = self.distribution.get_fullname()
        base_name = os.path.join(self.dist_dir, base_dir)

self.make_release_tree(base_dir, self.filelist.files)
        archive_files = []              # remember names of files we create
        # tar archive must be created last to avoid overwrite and remove
        if 'tar' in self.formats:
            self.formats.append(self.formats.pop(self.formats.index('tar')))

for fmt in self.formats:
            file = self.make_archive(base_name, fmt, base_dir=base_dir,
                                     owner=self.owner, group=self.group)
            archive_files.append(file)
            self.distribution.dist_files.append(('sdist', '', file))

self.archive_files = archive_files

if not self.keep_temp:
            dir_util.remove_tree(base_dir, dry_run=self.dry_run)

def get_archive_files(self):
        """Return the list of archive files created when the command
        was run, or None if the command hasn't run yet.
        """
        return self.archive_files
command/sdist.pyo000064400000040470151702014350010044 0ustar00�
{fc@sdZdZddlZddlZddlZddlmZddlmZddlm	Z	ddl
mZmZm
Z
mZddlmZdd	lmZmZmZdd
lmZddl
mZddlmZd
�Zde	fd��YZdS(sadistutils.command.sdist

'
cCs�tjd|j�t|jdddddddddddd�}zwxp|j�}|d
krhPny|jj|�WqLtt	fk
r�}|j
d	|j|j|f�qLXqLWWd
|j
�Xd
S(s�Read and parse manifest template file named by self.template.

(	R	!					*	(t__doc__t__revision__R;RaR�RtwarningsRtdistutils.coreRt	distutilsRRRRtdistutils.text_fileRtdistutils.errorsRR	R
tdistutils.filelistRRtdistutils.utilR
RR(((s//usr/lib64/python2.7/distutils/command/sdist.pyt<module>s"	command/upload.py000064400000015530151702014350010022 0ustar00"""distutils.command.upload

Implements the Distutils 'upload' subcommand (upload package to PyPI)."""
import os
import socket
import platform
from urllib2 import urlopen, Request, HTTPError
from base64 import standard_b64encode
import urlparse
import cStringIO as StringIO
from hashlib import md5

from distutils.errors import DistutilsError, DistutilsOptionError
from distutils.core import PyPIRCCommand
from distutils.spawn import spawn
from distutils import log

class upload(PyPIRCCommand):

description = "upload binary package to PyPI"

user_options = PyPIRCCommand.user_options + [
        ('sign', 's',
         'sign files to upload using gpg'),
        ('identity=', 'i', 'GPG identity used to sign files'),
        ]

boolean_options = PyPIRCCommand.boolean_options + ['sign']

def initialize_options(self):
        PyPIRCCommand.initialize_options(self)
        self.username = ''
        self.password = ''
        self.show_response = 0
        self.sign = False
        self.identity = None

def finalize_options(self):
        PyPIRCCommand.finalize_options(self)
        if self.identity and not self.sign:
            raise DistutilsOptionError(
                "Must use --sign for --identity to have meaning"
            )
        config = self._read_pypirc()
        if config != {}:
            self.username = config['username']
            self.password = config['password']
            self.repository = config['repository']
            self.realm = config['realm']

# getting the password from the distribution
        # if previously set by the register command
        if not self.password and self.distribution.password:
            self.password = self.distribution.password

def run(self):
        if not self.distribution.dist_files:
            msg = ("Must create and upload files in one command "
                   "(e.g. setup.py sdist upload)")
            raise DistutilsOptionError(msg)
        for command, pyversion, filename in self.distribution.dist_files:
            self.upload_file(command, pyversion, filename)

def upload_file(self, command, pyversion, filename):
        # Makes sure the repository URL is compliant
        schema, netloc, url, params, query, fragments = \
            urlparse.urlparse(self.repository)
        if params or query or fragments:
            raise AssertionError("Incompatible url %s" % self.repository)

if schema not in ('http', 'https'):
            raise AssertionError("unsupported schema " + schema)

# Sign if requested
        if self.sign:
            gpg_args = ["gpg", "--detach-sign", "-a", filename]
            if self.identity:
                gpg_args[2:2] = ["--local-user", self.identity]
            spawn(gpg_args,
                  dry_run=self.dry_run)

# Fill in the data - send all the meta-data in case we need to
        # register a new release
        f = open(filename,'rb')
        try:
            content = f.read()
        finally:
            f.close()
        meta = self.distribution.metadata
        data = {
            # action
            ':action': 'file_upload',
            'protcol_version': '1',

# identify release
            'name': meta.get_name(),
            'version': meta.get_version(),

# file content
            'content': (os.path.basename(filename),content),
            'filetype': command,
            'pyversion': pyversion,
            'md5_digest': md5(content).hexdigest(),

# additional meta-data
            'metadata_version' : '1.0',
            'summary': meta.get_description(),
            'home_page': meta.get_url(),
            'author': meta.get_contact(),
            'author_email': meta.get_contact_email(),
            'license': meta.get_licence(),
            'description': meta.get_long_description(),
            'keywords': meta.get_keywords(),
            'platform': meta.get_platforms(),
            'classifiers': meta.get_classifiers(),
            'download_url': meta.get_download_url(),
            # PEP 314
            'provides': meta.get_provides(),
            'requires': meta.get_requires(),
            'obsoletes': meta.get_obsoletes(),
            }
        comment = ''
        if command == 'bdist_rpm':
            dist, version, id = platform.dist()
            if dist:
                comment = 'built for %s %s' % (dist, version)
        elif command == 'bdist_dumb':
            comment = 'built for %s' % platform.platform(terse=1)
        data['comment'] = comment

if self.sign:
            data['gpg_signature'] = (os.path.basename(filename) + ".asc",
                                     open(filename+".asc").read())

# set up the authentication
        auth = "Basic " + standard_b64encode(self.username + ":" +
                                             self.password)

# Build up the MIME payload for the POST data
        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
        sep_boundary = '\r\n--' + boundary
        end_boundary = sep_boundary + '--\r\n'
        body = StringIO.StringIO()
        for key, value in data.items():
            # handle multiple entries for the same name
            if not isinstance(value, list):
                value = [value]
            for value in value:
                if isinstance(value, tuple):
                    fn = ';filename="%s"' % value[0]
                    value = value[1]
                else:
                    fn = ""

body.write(sep_boundary)
                body.write('\r\nContent-Disposition: form-data; name="%s"' % key)
                body.write(fn)
                body.write("\r\n\r\n")
                body.write(value)
        body.write(end_boundary)
        body = body.getvalue()

self.announce("Submitting %s to %s" % (filename, self.repository), log.INFO)

# build the Request
        headers = {'Content-type':
                        'multipart/form-data; boundary=%s' % boundary,
                   'Content-length': str(len(body)),
                   'Authorization': auth}

request = Request(self.repository, data=body,
                          headers=headers)
        # send the data
        try:
            result = urlopen(request)
            status = result.getcode()
            reason = result.msg
            if self.show_response:
                msg = '\n'.join(('-' * 75, result.read(), '-' * 75))
                self.announce(msg, log.INFO)
        except socket.error, e:
            self.announce(str(e), log.ERROR)
            raise
        except HTTPError, e:
            status = e.code
            reason = e.msg

if status == 200:
            self.announce('Server response (%s): %s' % (status, reason),
                          log.INFO)
        else:
            msg = 'Upload failed (%s): %s' % (status, reason)
            self.announce(msg, log.ERROR)
            raise DistutilsError(msg)
command/upload.pyc000064400000014244151702014350010166 0ustar00�
{fc@s�dZddlZddlZddlZddlmZmZmZddlm	Z	ddl
Z
ddlZddl
mZddlmZmZddlmZddlmZdd	lmZd
efd��YZdS(s`distutils.command.upload

Implements the Distutils 'upload' subcommand (upload package to PyPI).i����N(turlopentRequestt	HTTPError(tstandard_b64encode(tmd5(tDistutilsErrortDistutilsOptionError(t
PyPIRCCommand(tspawn(tlogtuploadcBsUeZdZejddgZejdgZd�Zd�Zd	�Zd
�Z	RS(
supload binary package to PyPItsigntsssign files to upload using gpgs	identity=tisGPG identity used to sign filescCs>tj|�d|_d|_d|_t|_d|_dS(Nti(	Rtinitialize_optionstusernametpasswordt
show_responsetFalseRtNonetidentity(tself((s0/usr/lib64/python2.7/distutils/command/upload.pyRs
				cCs�tj|�|jr/|jr/td��n|j�}|ikr~|d|_|d|_|d|_|d|_	n|jr�|j
jr�|j
j|_ndS(Ns.Must use --sign for --identity to have meaningRRt
repositorytrealm(Rtfinalize_optionsRRRt_read_pypircRRRRtdistribution(Rtconfig((s0/usr/lib64/python2.7/distutils/command/upload.pyR&s

cCsX|jjs!d}t|��nx0|jjD]"\}}}|j|||�q.WdS(NsHMust create and upload files in one command (e.g. setup.py sdist upload)(Rt
dist_filesRtupload_file(Rtmsgtcommandt	pyversiontfilename((s0/usr/lib64/python2.7/distutils/command/upload.pytrun8s
c"Cs`tj|j�\}}}}}}	|s6|s6|	rLtd|j��n|dEkrktd|��n|jr�ddd|g}
|jr�d|jg|
d	d	+nt|
d
|j�nt|d�}z|j�}Wd|j	�X|j
j}
idd
6dd6|
j�d6|
j
�d6tjj|�|fd6|d6|d6t|�j�d6dd6|
j�d6|
j�d6|
j�d6|
j�d6|
j�d6|
j�d6|
j�d6|
j�d6|
j�d 6|
j�d!6|
j�d"6|
j�d#6|
j�d$6}d%}|d&krRt j!�\}}}|rwd'||f}qwn%|d(krwd)t j d*d+�}n||d,<|jr�tjj|�d-t|d-�j�f|d.<nd/t"|j#d0|j$�}d1}d2|}|d3}t%j%�}x�|j&�D]�\}}t'|t(�s5|g}nx�|D]{}t'|t)�rld4|d5}|d+}nd%}|j*|�|j*d6|�|j*|�|j*d7�|j*|�q<WqW|j*|�|j+�}|j,d8||jft-j.�id9|d:6t/t0|��d;6|d<6}t1|jd=|d>|�}yjt2|�}|j3�}|j4}|j5r�d?j6d@dA|j�d@dAf�} |j,| t-j.�nWnVt7j8k
r�}!|j,t/|!�t-j9��n%t:k
r}!|!j;}|!j4}nX|dBkr-|j,dC||ft-j.�n/dD||f} |j,| t-j9�t<| ��dS(FNsIncompatible url %sthttpthttpssunsupported schema tgpgs
--detach-signs-as--local-useritdry_runtrbtfile_uploads:actiont1tprotcol_versiontnametversiontcontenttfiletypeR!t
md5_digests1.0tmetadata_versiontsummaryt	home_pagetauthortauthor_emailtlicensetdescriptiontkeywordstplatformtclassifierstdownload_urltprovidestrequirest	obsoletesRt	bdist_rpmsbuilt for %s %st
bdist_dumbsbuilt for %stterseitcomments.asct
gpg_signaturesBasic t:s3--------------GHSKFJDLGDS7543FJKLFHRE75642756743254s
--s--
s;filename="%s"is+
Content-Disposition: form-data; name="%s"s

sSubmitting %s to %ss multipart/form-data; boundary=%ssContent-typesContent-lengtht
Authorizationtdatatheaderss
t-iKi�sServer response (%s): %ssUpload failed (%s): %s(R$R%(=turlparseRtAssertionErrorRRRR'topentreadtcloseRtmetadatatget_nametget_versiontostpathtbasenameRt	hexdigesttget_descriptiontget_urltget_contacttget_contact_emailtget_licencetget_long_descriptiontget_keywordst
get_platformstget_classifierstget_download_urltget_providestget_requirest
get_obsoletesR9tdistRRRtStringIOtitemst
isinstancetlistttupletwritetgetvaluetannounceR	tINFOtstrtlenRRtgetcodeRRtjointsocketterrortERRORRtcodeR("RR R!R"tschematnetlocturltparamstqueryt	fragmentstgpg_argstfR.tmetaRFRBRbR-tidtauthtboundarytsep_boundarytend_boundarytbodytkeytvaluetfnRGtrequesttresulttstatustreasonRte((s0/usr/lib64/python2.7/distutils/command/upload.pyR@s�$

(RRssign files to upload using gpg(s	identity=R
sGPG identity used to sign files(
t__name__t
__module__R7Rtuser_optionstboolean_optionsRRR#R(((s0/usr/lib64/python2.7/distutils/command/upload.pyR
s
			(t__doc__RQRpR9turllib2RRRtbase64RRIt	cStringIORcthashlibRtdistutils.errorsRRtdistutils.coreRtdistutils.spawnRt	distutilsR	R
(((s0/usr/lib64/python2.7/distutils/command/upload.pyt<module>scommand/upload.pyo000064400000014244151702014350010202 0ustar00�
{fc@s�dZddlZddlZddlZddlmZmZmZddlm	Z	ddl
Z
ddlZddl
mZddlmZmZddlmZddlmZdd	lmZd
efd��YZdS(s`distutils.command.upload

(RRssign files to upload using gpg(s	identity=R
sGPG identity used to sign files(
t__name__t
__module__R7Rtuser_optionstboolean_optionsRRR#R(((s0/usr/lib64/python2.7/distutils/command/upload.pyR
s
			(t__doc__RQRpR9turllib2RRRtbase64RRIt	cStringIORcthashlibRtdistutils.errorsRRtdistutils.coreRtdistutils.spawnRt	distutilsR	R
(((s0/usr/lib64/python2.7/distutils/command/upload.pyt<module>scommand/__init__.py000064400000001466151702014350010300 0ustar00"""distutils.command

Package containing implementation of all the standard Distutils
commands."""

__revision__ = "$Id$"

__all__ = ['build',
           'build_py',
           'build_ext',
           'build_clib',
           'build_scripts',
           'clean',
           'install',
           'install_lib',
           'install_headers',
           'install_scripts',
           'install_data',
           'sdist',
           'register',
           'bdist',
           'bdist_dumb',
           'bdist_rpm',
           'bdist_wininst',
           'upload',
           'check',
           # These two are reserved for future use:
           #'bdist_sdux',
           #'bdist_pkgtool',
           # Note:
           # bdist_packager is not included because it only provides
           # an abstract base class
          ]
command/__init__.pyc000064400000001231151702014350010431 0ustar00�
{fc@sOdZdZdddddddd	d
ddd
dddddddgZdS(s\distutils.command

Package containing implementation of all the standard Distutils
commands.s$Id$tbuildtbuild_pyt	build_extt
build_clibt
build_scriptstcleantinstalltinstall_libtinstall_headerstinstall_scriptstinstall_datatsdisttregistertbdistt
bdist_dumbt	bdist_rpmt
bdist_wininsttuploadtcheckN(t__doc__t__revision__t__all__(((s2/usr/lib64/python2.7/distutils/command/__init__.pyt<module>s(command/__init__.pyo000064400000001231151702014350010445 0ustar00�
{fc@sOdZdZdddddddd	d
ddd
dddddddgZdS(s\distutils.command

Package containing implementation of all the standard Distutils
commands.s$Id$tbuildtbuild_pyt	build_extt
build_clibt
build_scriptstcleantinstalltinstall_libtinstall_headerstinstall_scriptstinstall_datatsdisttregistertbdistt
bdist_dumbt	bdist_rpmt
bdist_wininsttuploadtcheckN(t__doc__t__revision__t__all__(((s2/usr/lib64/python2.7/distutils/command/__init__.pyt<module>s(command/bdist.py000064400000012734151702014350007646 0ustar00"""distutils.command.bdist

Implements the Distutils 'bdist' command (create a built [binary]
distribution)."""

__revision__ = "$Id$"

import os

from distutils.util import get_platform
from distutils.core import Command
from distutils.errors import DistutilsPlatformError, DistutilsOptionError

def show_formats():
    """Print list of available formats (arguments to "--format" option).
    """
    from distutils.fancy_getopt import FancyGetopt
    formats = []
    for format in bdist.format_commands:
        formats.append(("formats=" + format, None,
                        bdist.format_command[format][1]))
    pretty_printer = FancyGetopt(formats)
    pretty_printer.print_help("List of available distribution formats:")

class bdist(Command):

description = "create a built (binary) distribution"

user_options = [('bdist-base=', 'b',
                     "temporary directory for creating built distributions"),
                    ('plat-name=', 'p',
                     "platform name to embed in generated filenames "
                     "(default: %s)" % get_platform()),
                    ('formats=', None,
                     "formats for distribution (comma-separated list)"),
                    ('dist-dir=', 'd',
                     "directory to put final built distributions in "
                     "[default: dist]"),
                    ('skip-build', None,
                     "skip rebuilding everything (for testing/debugging)"),
                    ('owner=', 'u',
                     "Owner name used when creating a tar file"
                     " [default: current user]"),
                    ('group=', 'g',
                     "Group name used when creating a tar file"
                     " [default: current group]"),
                   ]

boolean_options = ['skip-build']

help_options = [
        ('help-formats', None,
         "lists available distribution formats", show_formats),
        ]

# The following commands do not take a format option from bdist
    no_format_option = ('bdist_rpm',)

# This won't do in reality: will need to distinguish RPM-ish Linux,
    # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
    default_format = {'posix': 'gztar',
                      'nt': 'zip',
                      'os2': 'zip'}

# Establish the preferred order (for the --help-formats option).
    format_commands = ['rpm', 'gztar', 'bztar', 'ztar', 'tar',
                       'wininst', 'zip', 'msi']

# And the real information.
    format_command = {'rpm':   ('bdist_rpm',  "RPM distribution"),
                      'gztar': ('bdist_dumb', "gzip'ed tar file"),
                      'bztar': ('bdist_dumb', "bzip2'ed tar file"),
                      'ztar':  ('bdist_dumb', "compressed tar file"),
                      'tar':   ('bdist_dumb', "tar file"),
                      'wininst': ('bdist_wininst',
                                  "Windows executable installer"),
                      'zip':   ('bdist_dumb', "ZIP file"),
                      'msi':   ('bdist_msi',  "Microsoft Installer")
                      }

def initialize_options(self):
        self.bdist_base = None
        self.plat_name = None
        self.formats = None
        self.dist_dir = None
        self.skip_build = 0
        self.group = None
        self.owner = None

def finalize_options(self):
        # have to finalize 'plat_name' before 'bdist_base'
        if self.plat_name is None:
            if self.skip_build:
                self.plat_name = get_platform()
            else:
                self.plat_name = self.get_finalized_command('build').plat_name

# 'bdist_base' -- parent of per-built-distribution-format
        # temporary directories (eg. we'll probably have
        # "build/bdist.<plat>/dumb", "build/bdist.<plat>/rpm", etc.)
        if self.bdist_base is None:
            build_base = self.get_finalized_command('build').build_base
            self.bdist_base = os.path.join(build_base,
                                           'bdist.' + self.plat_name)

self.ensure_string_list('formats')
        if self.formats is None:
            try:
                self.formats = [self.default_format[os.name]]
            except KeyError:
                raise DistutilsPlatformError, \
                      "don't know how to create built distributions " + \
                      "on platform %s" % os.name

if self.dist_dir is None:
            self.dist_dir = "dist"

def run(self):
        # Figure out which sub-commands we need to run.
        commands = []
        for format in self.formats:
            try:
                commands.append(self.format_command[format][0])
            except KeyError:
                raise DistutilsOptionError, "invalid format '%s'" % format

# Reinitialize and run each command.
        for i in range(len(self.formats)):
            cmd_name = commands[i]
            sub_cmd = self.reinitialize_command(cmd_name)
            if cmd_name not in self.no_format_option:
                sub_cmd.format = self.formats[i]

# passing the owner and group names for tar archiving
            if cmd_name == 'bdist_dumb':
                sub_cmd.owner = self.owner
                sub_cmd.group = self.group

# If we're going to need to run this command again, tell it to
            # keep its temporary files around so subsequent runs go faster.
            if cmd_name in commands[i+1:]:
                sub_cmd.keep_temp = 1
            self.run_command(cmd_name)
command/bdist.pyc000064400000012061151702014350010002 0ustar00�
{fc@sqdZdZddlZddlmZddlmZddlmZm	Z	d�Z
defd	��YZdS(
sidistutils.command.bdist

Implements the Distutils 'bdist' command (create a built [binary]
distribution).s$Id$i����N(tget_platform(tCommand(tDistutilsPlatformErrortDistutilsOptionErrorcCslddlm}g}x6tjD]+}|jd|dtj|df�q W||�}|jd�dS(sFPrint list of available formats (arguments to "--format" option).
    i����(tFancyGetoptsformats=is'List of available distribution formats:N(tdistutils.fancy_getoptRtbdisttformat_commandstappendtNonetformat_commandt
print_help(Rtformatstformattpretty_printer((s//usr/lib64/python2.7/distutils/command/bdist.pytshow_formatssRc	Bs�eZdZd0ddde�fd2d3d4d5d6gZdgZdd1defgZd7Z	idd6dd6dd6Z
dddddd dd!gZid8d6d9d6d:d6d;d6d<d6d=d 6d>d6d?d!6Zd-�Z
d.�Zd/�ZRS(@s$create a built (binary) distributionsbdist-base=tbs4temporary directory for creating built distributionss
plat-name=tps;platform name to embed in generated filenames (default: %s)sformats=s/formats for distribution (comma-separated list)s	dist-dir=tds=directory to put final built distributions in [default: dist]s
skip-builds2skip rebuilding everything (for testing/debugging)sowner=tus@Owner name used when creating a tar file [default: current user]sgroup=tgsAGroup name used when creating a tar file [default: current group]shelp-formatss$lists available distribution formatst	bdist_rpmtgztartposixtziptnttos2trpmtbztartztarttartwininsttmsisRPM distributiont
bdist_dumbsgzip'ed tar filesbzip2'ed tar filescompressed tar filestar filet
bdist_wininstsWindows executable installersZIP filet	bdist_msisMicrosoft InstallercCsCd|_d|_d|_d|_d|_d|_d|_dS(Ni(R	t
bdist_baset	plat_nameRtdist_dirt
skip_buildtgrouptowner(tself((s//usr/lib64/python2.7/distutils/command/bdist.pytinitialize_optionsTs						cCs|jdkr?|jr't�|_q?|jd�j|_n|jdkr�|jd�j}tjj	|d|j�|_n|j
d�|jdkr�y|jtj
g|_Wq�tk
r�tddtj
�q�Xn|jdkr�d|_ndS(Ntbuildsbdist.Rs-don't know how to create built distributions son platform %stdist(R%R	R'Rtget_finalized_commandR$t
build_basetostpathtjointensure_string_listRtdefault_formattnametKeyErrorRR&(R*R/((s//usr/lib64/python2.7/distutils/command/bdist.pytfinalize_options]s$

cCs
g}xN|jD]C}y|j|j|d�Wqtk
rRtd|�qXqWx�tt|j��D]�}||}|j|�}||jkr�|j||_	n|dkr�|j
|_
|j|_n|||dkr�d|_n|j
|�qmWdS(Nisinvalid format '%s'R!i(RRR
R6Rtrangetlentreinitialize_commandtno_format_optionR
R)R(t	keep_temptrun_command(R*tcommandsR
titcmd_nametsub_cmd((s//usr/lib64/python2.7/distutils/command/bdist.pytrunys"

(sbdist-base=Rs4temporary directory for creating built distributionsN(sformats=Ns/formats for distribution (comma-separated list)(s	dist-dir=Rs=directory to put final built distributions in [default: dist](s
skip-buildNs2skip rebuilding everything (for testing/debugging)(sowner=Rs@Owner name used when creating a tar file [default: current user](sgroup=RsAGroup name used when creating a tar file [default: current group](R(RsRPM distribution(R!sgzip'ed tar file(R!sbzip2'ed tar file(R!scompressed tar file(R!star file(R"sWindows executable installer(R!sZIP file(R#sMicrosoft Installer(t__name__t
__module__tdescriptionRR	tuser_optionstboolean_optionsRthelp_optionsR;R4RR
R+R7RB(((s//usr/lib64/python2.7/distutils/command/bdist.pyRsJ

(t__doc__t__revision__R0tdistutils.utilRtdistutils.coreRtdistutils.errorsRRRR(((s//usr/lib64/python2.7/distutils/command/bdist.pyt<module>s	command/bdist.pyo000064400000012061151702014350010016 0ustar00�
{fc@sqdZdZddlZddlmZddlmZddlmZm	Z	d�Z
defd	��YZdS(
sidistutils.command.bdist

(t__doc__t__revision__R0tdistutils.utilRtdistutils.coreRtdistutils.errorsRRRR(((s//usr/lib64/python2.7/distutils/command/bdist.pyt<module>s	command/bdist_dumb.py000064400000012114151702014350010645 0ustar00"""distutils.command.bdist_dumb

Implements the Distutils 'bdist_dumb' command (create a "dumb" built
distribution -- i.e., just an archive to be unpacked under $prefix or
$exec_prefix)."""

__revision__ = "$Id$"

import os

from sysconfig import get_python_version

from distutils.util import get_platform
from distutils.core import Command
from distutils.dir_util import remove_tree, ensure_relative
from distutils.errors import DistutilsPlatformError
from distutils import log

class bdist_dumb (Command):

description = 'create a "dumb" built distribution'

user_options = [('bdist-dir=', 'd',
                     "temporary directory for creating the distribution"),
                    ('plat-name=', 'p',
                     "platform name to embed in generated filenames "
                     "(default: %s)" % get_platform()),
                    ('format=', 'f',
                     "archive format to create (tar, ztar, gztar, zip)"),
                    ('keep-temp', 'k',
                     "keep the pseudo-installation tree around after " +
                     "creating the distribution archive"),
                    ('dist-dir=', 'd',
                     "directory to put final built distributions in"),
                    ('skip-build', None,
                     "skip rebuilding everything (for testing/debugging)"),
                    ('relative', None,
                     "build the archive using relative paths "
                     "(default: false)"),
                    ('owner=', 'u',
                     "Owner name used when creating a tar file"
                     " [default: current user]"),
                    ('group=', 'g',
                     "Group name used when creating a tar file"
                     " [default: current group]"),
                   ]

boolean_options = ['keep-temp', 'skip-build', 'relative']

default_format = { 'posix': 'gztar',
                       'nt': 'zip',
                       'os2': 'zip' }

def initialize_options (self):
        self.bdist_dir = None
        self.plat_name = None
        self.format = None
        self.keep_temp = 0
        self.dist_dir = None
        self.skip_build = None
        self.relative = 0
        self.owner = None
        self.group = None

def finalize_options(self):
        if self.bdist_dir is None:
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'dumb')

if self.format is None:
            try:
                self.format = self.default_format[os.name]
            except KeyError:
                raise DistutilsPlatformError, \
                      ("don't know how to create dumb built distributions " +
                       "on platform %s") % os.name

self.set_undefined_options('bdist',
                                   ('dist_dir', 'dist_dir'),
                                   ('plat_name', 'plat_name'),
                                   ('skip_build', 'skip_build'))

def run(self):
        if not self.skip_build:
            self.run_command('build')

install = self.reinitialize_command('install', reinit_subcommands=1)
        install.root = self.bdist_dir
        install.skip_build = self.skip_build
        install.warn_dir = 0

log.info("installing to %s" % self.bdist_dir)
        self.run_command('install')

# And make an archive relative to the root of the
        # pseudo-installation tree.
        archive_basename = "%s.%s" % (self.distribution.get_fullname(),
                                      self.plat_name)

# OS/2 objects to any ":" characters in a filename (such as when
        # a timestamp is used in a version) so change them to hyphens.
        if os.name == "os2":
            archive_basename = archive_basename.replace(":", "-")

pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
        if not self.relative:
            archive_root = self.bdist_dir
        else:
            if (self.distribution.has_ext_modules() and
                (install.install_base != install.install_platbase)):
                raise DistutilsPlatformError, \
                      ("can't make a dumb built distribution where "
                       "base and platbase are different (%s, %s)"
                       % (repr(install.install_base),
                          repr(install.install_platbase)))
            else:
                archive_root = os.path.join(self.bdist_dir,
                                   ensure_relative(install.install_base))

# Make the archive
        filename = self.make_archive(pseudoinstall_root,
                                     self.format, root_dir=archive_root,
                                     owner=self.owner, group=self.group)
        if self.distribution.has_ext_modules():
            pyversion = get_python_version()
        else:
            pyversion = 'any'
        self.distribution.dist_files.append(('bdist_dumb', pyversion,
                                             filename))

if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)
command/bdist_dumb.pyc000064400000011567151702014350011023 0ustar00�
{fc@s�dZdZddlZddlmZddlmZddlmZddl	m
Z
mZddlm
Z
dd	lmZd
efd��YZdS(s�distutils.command.bdist_dumb

Implements the Distutils 'bdist_dumb' command (create a "dumb" built
distribution -- i.e., just an archive to be unpacked under $prefix or
$exec_prefix).s$Id$i����N(tget_python_version(tget_platform(tCommand(tremove_treetensure_relative(tDistutilsPlatformError(tlogt
bdist_dumbcBs�eZdZd"ddde�fd#d
ddd
fd$d&d'd(d)g	Zd
ddgZidd6dd6dd6Zd�Zd �Z	d!�Z
RS(*s"create a "dumb" built distributions
bdist-dir=tds1temporary directory for creating the distributions
plat-name=tps;platform name to embed in generated filenames (default: %s)sformat=tfs0archive format to create (tar, ztar, gztar, zip)s	keep-temptks/keep the pseudo-installation tree around after s!creating the distribution archives	dist-dir=s-directory to put final built distributions ins
skip-builds2skip rebuilding everything (for testing/debugging)trelatives7build the archive using relative paths (default: false)sowner=tus@Owner name used when creating a tar file [default: current user]sgroup=tgsAGroup name used when creating a tar file [default: current group]tgztartposixtziptnttos2cCsUd|_d|_d|_d|_d|_d|_d|_d|_d|_	dS(Ni(
tNonet	bdist_dirt	plat_nametformatt	keep_temptdist_dirt
skip_buildRtownertgroup(tself((s4/usr/lib64/python2.7/distutils/command/bdist_dumb.pytinitialize_options7s								cCs�|jdkr<|jd�j}tjj|d�|_n|jdkr�y|jtj	|_Wq�t
k
r�tddtj	�q�Xn|jddd	d
�dS(Ntbdisttdumbs2don't know how to create dumb built distributions son platform %sRRR(RR(RR(RR(
RRtget_finalized_commandt
bdist_basetostpathtjoinRtdefault_formattnametKeyErrorRtset_undefined_options(RR"((s4/usr/lib64/python2.7/distutils/command/bdist_dumb.pytfinalize_optionsBs
	c	Cs�|js|jd�n|jddd�}|j|_|j|_d|_tjd|j�|jd�d|jj	�|j
f}tjdkr�|j
d	d
�}ntjj|j|�}|js�|j}nj|jj�r&|j|jkr&tdt|j�t|j�f�n!tjj|jt|j��}|j||jd|d
|jd|j�}|jj�r�t�}nd}|jjjd||f�|js�t |jd|j!�ndS(Ntbuildtinstalltreinit_subcommandsiisinstalling to %ss%s.%sRt:t-sScan't make a dumb built distribution where base and platbase are different (%s, %s)troot_dirRRtanyRtdry_run("Rtrun_commandtreinitialize_commandRtroottwarn_dirRtinfotdistributiontget_fullnameRR#R'treplaceR$R%RRthas_ext_modulestinstall_basetinstall_platbaseRtreprRtmake_archiveRRRRt
dist_filestappendRRR2(RR,tarchive_basenametpseudoinstall_roottarchive_roottfilenamet	pyversion((s4/usr/lib64/python2.7/distutils/command/bdist_dumb.pytrunTsB

(s
bdist-dir=Rs1temporary directory for creating the distribution(sformat=R
s0archive format to create (tar, ztar, gztar, zip)(s	dist-dir=Rs-directory to put final built distributions inN(s
skip-buildNs2skip rebuilding everything (for testing/debugging)(RNs7build the archive using relative paths (default: false)(sowner=R
s@Owner name used when creating a tar file [default: current user](sgroup=RsAGroup name used when creating a tar file [default: current group](t__name__t
__module__tdescriptionRRtuser_optionstboolean_optionsR&RR*RG(((s4/usr/lib64/python2.7/distutils/command/bdist_dumb.pyRs8

(t__doc__t__revision__R#t	sysconfigRtdistutils.utilRtdistutils.coreRtdistutils.dir_utilRRtdistutils.errorsRt	distutilsRR(((s4/usr/lib64/python2.7/distutils/command/bdist_dumb.pyt<module>scommand/bdist_msi.py000064400000104571151702014350010517 0ustar00# -*- coding: iso-8859-1 -*-
# Copyright (C) 2005, 2006 Martin von L�wis
# Licensed to PSF under a Contributor Agreement.
# The bdist_wininst command proper
# based on bdist_wininst
"""
Implements the bdist_msi command.
"""
import sys, os
from sysconfig import get_python_version

from distutils.core import Command
from distutils.dir_util import remove_tree
from distutils.version import StrictVersion
from distutils.errors import DistutilsOptionError
from distutils import log
from distutils.util import get_platform

import msilib
from msilib import schema, sequence, text
from msilib import Directory, Feature, Dialog, add_data

class PyDialog(Dialog):
    """Dialog class with a fixed layout: controls at the top, then a ruler,
    then a list of buttons: back, next, cancel. Optionally a bitmap at the
    left."""
    def __init__(self, *args, **kw):
        """Dialog(database, name, x, y, w, h, attributes, title, first,
        default, cancel, bitmap=true)"""
        Dialog.__init__(self, *args)
        ruler = self.h - 36
        #if kw.get("bitmap", True):
        #    self.bitmap("Bitmap", 0, 0, bmwidth, ruler, "PythonWin")
        self.line("BottomLine", 0, ruler, self.w, 0)

def title(self, title):
        "Set the title text of the dialog at the top."
        # name, x, y, w, h, flags=Visible|Enabled|Transparent|NoPrefix,
        # text, in VerdanaBold10
        self.text("Title", 15, 10, 320, 60, 0x30003,
                  r"{\VerdanaBold10}%s" % title)

def back(self, title, next, name = "Back", active = 1):
        """Add a back button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

Return the button, so that events can be associated"""
        if active:
            flags = 3 # Visible|Enabled
        else:
            flags = 1 # Visible
        return self.pushbutton(name, 180, self.h-27 , 56, 17, flags, title, next)

def cancel(self, title, next, name = "Cancel", active = 1):
        """Add a cancel button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

Return the button, so that events can be associated"""
        if active:
            flags = 3 # Visible|Enabled
        else:
            flags = 1 # Visible
        return self.pushbutton(name, 304, self.h-27, 56, 17, flags, title, next)

def next(self, title, next, name = "Next", active = 1):
        """Add a Next button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

Return the button, so that events can be associated"""
        if active:
            flags = 3 # Visible|Enabled
        else:
            flags = 1 # Visible
        return self.pushbutton(name, 236, self.h-27, 56, 17, flags, title, next)

def xbutton(self, name, title, next, xpos):
        """Add a button with a given title, the tab-next button,
        its name in the Control table, giving its x position; the
        y-position is aligned with the other buttons.

Return the button, so that events can be associated"""
        return self.pushbutton(name, int(self.w*xpos - 28), self.h-27, 56, 17, 3, title, next)

class bdist_msi (Command):

description = "create a Microsoft Installer (.msi) binary distribution"

user_options = [('bdist-dir=', None,
                     "temporary directory for creating the distribution"),
                    ('plat-name=', 'p',
                     "platform name to embed in generated filenames "
                     "(default: %s)" % get_platform()),
                    ('keep-temp', 'k',
                     "keep the pseudo-installation tree around after " +
                     "creating the distribution archive"),
                    ('target-version=', None,
                     "require a specific python version" +
                     " on the target system"),
                    ('no-target-compile', 'c',
                     "do not compile .py to .pyc on the target system"),
                    ('no-target-optimize', 'o',
                     "do not compile .py to .pyo (optimized) "
                     "on the target system"),
                    ('dist-dir=', 'd',
                     "directory to put final built distributions in"),
                    ('skip-build', None,
                     "skip rebuilding everything (for testing/debugging)"),
                    ('install-script=', None,
                     "basename of installation script to be run after "
                     "installation or before deinstallation"),
                    ('pre-install-script=', None,
                     "Fully qualified filename of a script to be run before "
                     "any files are installed.  This script need not be in the "
                     "distribution"),
                   ]

boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
                       'skip-build']

all_versions = ['2.0', '2.1', '2.2', '2.3', '2.4',
                    '2.5', '2.6', '2.7', '2.8', '2.9',
                    '3.0', '3.1', '3.2', '3.3', '3.4',
                    '3.5', '3.6', '3.7', '3.8', '3.9']
    other_version = 'X'

def initialize_options (self):
        self.bdist_dir = None
        self.plat_name = None
        self.keep_temp = 0
        self.no_target_compile = 0
        self.no_target_optimize = 0
        self.target_version = None
        self.dist_dir = None
        self.skip_build = None
        self.install_script = None
        self.pre_install_script = None
        self.versions = None

def finalize_options (self):
        self.set_undefined_options('bdist', ('skip_build', 'skip_build'))

if self.bdist_dir is None:
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'msi')

short_version = get_python_version()
        if (not self.target_version) and self.distribution.has_ext_modules():
            self.target_version = short_version

if self.target_version:
            self.versions = [self.target_version]
            if not self.skip_build and self.distribution.has_ext_modules()\
               and self.target_version != short_version:
                raise DistutilsOptionError, \
                      "target version can only be %s, or the '--skip-build'" \
                      " option must be specified" % (short_version,)
        else:
            self.versions = list(self.all_versions)

self.set_undefined_options('bdist',
                                   ('dist_dir', 'dist_dir'),
                                   ('plat_name', 'plat_name'),
                                   )

if self.pre_install_script:
            raise DistutilsOptionError, "the pre-install-script feature is not yet implemented"

def run (self):
        if not self.skip_build:
            self.run_command('build')

install = self.reinitialize_command('install', reinit_subcommands=1)
        install.prefix = self.bdist_dir
        install.skip_build = self.skip_build
        install.warn_dir = 0

install_lib = self.reinitialize_command('install_lib')
        # we do not want to include pyc or pyo files
        install_lib.compile = 0
        install_lib.optimize = 0

log.info("installing to %s", self.bdist_dir)
        install.ensure_finalized()

# avoid warning of 'install_lib' about installing
        # into a directory not in sys.path
        sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))

install.run()

del sys.path[0]

self.mkpath(self.dist_dir)
        fullname = self.distribution.get_fullname()
        installer_name = self.get_installer_filename(fullname)
        installer_name = os.path.abspath(installer_name)
        if os.path.exists(installer_name): os.unlink(installer_name)

metadata = self.distribution.metadata
        author = metadata.author
        if not author:
            author = metadata.maintainer
        if not author:
            author = "UNKNOWN"
        version = metadata.get_version()
        # ProductVersion must be strictly numeric
        # XXX need to deal with prerelease versions
        sversion = "%d.%d.%d" % StrictVersion(version).version
        # Prefix ProductName with Python x.y, so that
        # it sorts together with the other Python packages
        # in Add-Remove-Programs (APR)
        fullname = self.distribution.get_fullname()
        if self.target_version:
            product_name = "Python %s %s" % (self.target_version, fullname)
        else:
            product_name = "Python %s" % (fullname)
        self.db = msilib.init_database(installer_name, schema,
                product_name, msilib.gen_uuid(),
                sversion, author)
        msilib.add_tables(self.db, sequence)
        props = [('DistVersion', version)]
        email = metadata.author_email or metadata.maintainer_email
        if email:
            props.append(("ARPCONTACT", email))
        if metadata.url:
            props.append(("ARPURLINFOABOUT", metadata.url))
        if props:
            add_data(self.db, 'Property', props)

self.add_find_python()
        self.add_files()
        self.add_scripts()
        self.add_ui()
        self.db.Commit()

if hasattr(self.distribution, 'dist_files'):
            tup = 'bdist_msi', self.target_version or 'any', fullname
            self.distribution.dist_files.append(tup)

if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)

def add_files(self):
        db = self.db
        cab = msilib.CAB("distfiles")
        rootdir = os.path.abspath(self.bdist_dir)

root = Directory(db, cab, None, rootdir, "TARGETDIR", "SourceDir")
        f = Feature(db, "Python", "Python", "Everything",
                    0, 1, directory="TARGETDIR")

items = [(f, root, '')]
        for version in self.versions + [self.other_version]:
            target = "TARGETDIR" + version
            name = default = "Python" + version
            desc = "Everything"
            if version is self.other_version:
                title = "Python from another location"
                level = 2
            else:
                title = "Python %s from registry" % version
                level = 1
            f = Feature(db, name, title, desc, 1, level, directory=target)
            dir = Directory(db, cab, root, rootdir, target, default)
            items.append((f, dir, version))
        db.Commit()

seen = {}
        for feature, dir, version in items:
            todo = [dir]
            while todo:
                dir = todo.pop()
                for file in os.listdir(dir.absolute):
                    afile = os.path.join(dir.absolute, file)
                    if os.path.isdir(afile):
                        short = "%s|%s" % (dir.make_short(file), file)
                        default = file + version
                        newdir = Directory(db, cab, dir, file, default, short)
                        todo.append(newdir)
                    else:
                        if not dir.component:
                            dir.start_component(dir.logical, feature, 0)
                        if afile not in seen:
                            key = seen[afile] = dir.add_file(file)
                            if file==self.install_script:
                                if self.install_script_key:
                                    raise DistutilsOptionError(
                                          "Multiple files with name %s" % file)
                                self.install_script_key = '[#%s]' % key
                        else:
                            key = seen[afile]
                            add_data(self.db, "DuplicateFile",
                                [(key + version, dir.component, key, None, dir.logical)])
            db.Commit()
        cab.commit(db)

def add_find_python(self):
        """Adds code to the installer to compute the location of Python.

Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
        registry for each version of Python.

Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
        else from PYTHON.MACHINE.X.Y.

Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe"""

start = 402
        for ver in self.versions:
            install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver
            machine_reg = "python.machine." + ver
            user_reg = "python.user." + ver
            machine_prop = "PYTHON.MACHINE." + ver
            user_prop = "PYTHON.USER." + ver
            machine_action = "PythonFromMachine" + ver
            user_action = "PythonFromUser" + ver
            exe_action = "PythonExe" + ver
            target_dir_prop = "TARGETDIR" + ver
            exe_prop = "PYTHON" + ver
            if msilib.Win64:
                # type: msidbLocatorTypeRawValue + msidbLocatorType64bit
                Type = 2+16
            else:
                Type = 2
            add_data(self.db, "RegLocator",
                    [(machine_reg, 2, install_path, None, Type),
                     (user_reg, 1, install_path, None, Type)])
            add_data(self.db, "AppSearch",
                    [(machine_prop, machine_reg),
                     (user_prop, user_reg)])
            add_data(self.db, "CustomAction",
                    [(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"),
                     (user_action, 51+256, target_dir_prop, "[" + user_prop + "]"),
                     (exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"),
                    ])
            add_data(self.db, "InstallExecuteSequence",
                    [(machine_action, machine_prop, start),
                     (user_action, user_prop, start + 1),
                     (exe_action, None, start + 2),
                    ])
            add_data(self.db, "InstallUISequence",
                    [(machine_action, machine_prop, start),
                     (user_action, user_prop, start + 1),
                     (exe_action, None, start + 2),
                    ])
            add_data(self.db, "Condition",
                    [("Python" + ver, 0, "NOT TARGETDIR" + ver)])
            start += 4
            assert start < 500

def add_scripts(self):
        if self.install_script:
            start = 6800
            for ver in self.versions + [self.other_version]:
                install_action = "install_script." + ver
                exe_prop = "PYTHON" + ver
                add_data(self.db, "CustomAction",
                        [(install_action, 50, exe_prop, self.install_script_key)])
                add_data(self.db, "InstallExecuteSequence",
                        [(install_action, "&Python%s=3" % ver, start)])
                start += 1
        # XXX pre-install scripts are currently refused in finalize_options()
        #     but if this feature is completed, it will also need to add
        #     entries for each version as the above code does
        if self.pre_install_script:
            scriptfn = os.path.join(self.bdist_dir, "preinstall.bat")
            f = open(scriptfn, "w")
            # The batch file will be executed with [PYTHON], so that %1
            # is the path to the Python interpreter; %0 will be the path
            # of the batch file.
            # rem ="""
            # %1 %0
            # exit
            # """
            # <actual script>
            f.write('rem ="""\n%1 %0\nexit\n"""\n')
            f.write(open(self.pre_install_script).read())
            f.close()
            add_data(self.db, "Binary",
                [("PreInstall", msilib.Binary(scriptfn))
                ])
            add_data(self.db, "CustomAction",
                [("PreInstall", 2, "PreInstall", None)
                ])
            add_data(self.db, "InstallExecuteSequence",
                    [("PreInstall", "NOT Installed", 450)])

def add_ui(self):
        db = self.db
        x = y = 50
        w = 370
        h = 300
        title = "[ProductName] Setup"

# see "Dialog Style Bits"
        modal = 3      # visible | modal
        modeless = 1   # visible

# UI customization properties
        add_data(db, "Property",
                 # See "DefaultUIFont Property"
                 [("DefaultUIFont", "DlgFont8"),
                  # See "ErrorDialog Style Bit"
                  ("ErrorDialog", "ErrorDlg"),
                  ("Progress1", "Install"),   # modified in maintenance type dlg
                  ("Progress2", "installs"),
                  ("MaintenanceForm_Action", "Repair"),
                  # possible values: ALL, JUSTME
                  ("WhichUsers", "ALL")
                 ])

# Fonts, see "TextStyle Table"
        add_data(db, "TextStyle",
                 [("DlgFont8", "Tahoma", 9, None, 0),
                  ("DlgFontBold8", "Tahoma", 8, None, 1), #bold
                  ("VerdanaBold10", "Verdana", 10, None, 1),
                  ("VerdanaRed9", "Verdana", 9, 255, 0),
                 ])

# UI Sequences, see "InstallUISequence Table", "Using a Sequence Table"
        # Numbers indicate sequence; see sequence.py for how these action integrate
        add_data(db, "InstallUISequence",
                 [("PrepareDlg", "Not Privileged or Windows9x or Installed", 140),
                  ("WhichUsersDlg", "Privileged and not Windows9x and not Installed", 141),
                  # In the user interface, assume all-users installation if privileged.
                  ("SelectFeaturesDlg", "Not Installed", 1230),
                  # XXX no support for resume installations yet
                  #("ResumeDlg", "Installed AND (RESUME OR Preselected)", 1240),
                  ("MaintenanceTypeDlg", "Installed AND NOT RESUME AND NOT Preselected", 1250),
                  ("ProgressDlg", None, 1280)])

add_data(db, 'ActionText', text.ActionText)
        add_data(db, 'UIText', text.UIText)
        #####################################################################
        # Standard dialogs: FatalError, UserExit, ExitDialog
        fatal=PyDialog(db, "FatalError", x, y, w, h, modal, title,
                     "Finish", "Finish", "Finish")
        fatal.title("[ProductName] Installer ended prematurely")
        fatal.back("< Back", "Finish", active = 0)
        fatal.cancel("Cancel", "Back", active = 0)
        fatal.text("Description1", 15, 70, 320, 80, 0x30003,
                   "[ProductName] setup ended prematurely because of an error.  Your system has not been modified.  To install this program at a later time, please run the installation again.")
        fatal.text("Description2", 15, 155, 320, 20, 0x30003,
                   "Click the Finish button to exit the Installer.")
        c=fatal.next("Finish", "Cancel", name="Finish")
        c.event("EndDialog", "Exit")

user_exit=PyDialog(db, "UserExit", x, y, w, h, modal, title,
                     "Finish", "Finish", "Finish")
        user_exit.title("[ProductName] Installer was interrupted")
        user_exit.back("< Back", "Finish", active = 0)
        user_exit.cancel("Cancel", "Back", active = 0)
        user_exit.text("Description1", 15, 70, 320, 80, 0x30003,
                   "[ProductName] setup was interrupted.  Your system has not been modified.  "
                   "To install this program at a later time, please run the installation again.")
        user_exit.text("Description2", 15, 155, 320, 20, 0x30003,
                   "Click the Finish button to exit the Installer.")
        c = user_exit.next("Finish", "Cancel", name="Finish")
        c.event("EndDialog", "Exit")

exit_dialog = PyDialog(db, "ExitDialog", x, y, w, h, modal, title,
                             "Finish", "Finish", "Finish")
        exit_dialog.title("Completing the [ProductName] Installer")
        exit_dialog.back("< Back", "Finish", active = 0)
        exit_dialog.cancel("Cancel", "Back", active = 0)
        exit_dialog.text("Description", 15, 235, 320, 20, 0x30003,
                   "Click the Finish button to exit the Installer.")
        c = exit_dialog.next("Finish", "Cancel", name="Finish")
        c.event("EndDialog", "Return")

#####################################################################
        # Required dialog: FilesInUse, ErrorDlg
        inuse = PyDialog(db, "FilesInUse",
                         x, y, w, h,
                         19,                # KeepModeless|Modal|Visible
                         title,
                         "Retry", "Retry", "Retry", bitmap=False)
        inuse.text("Title", 15, 6, 200, 15, 0x30003,
                   r"{\DlgFontBold8}Files in Use")
        inuse.text("Description", 20, 23, 280, 20, 0x30003,
               "Some files that need to be updated are currently in use.")
        inuse.text("Text", 20, 55, 330, 50, 3,
                   "The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.")
        inuse.control("List", "ListBox", 20, 107, 330, 130, 7, "FileInUseProcess",
                      None, None, None)
        c=inuse.back("Exit", "Ignore", name="Exit")
        c.event("EndDialog", "Exit")
        c=inuse.next("Ignore", "Retry", name="Ignore")
        c.event("EndDialog", "Ignore")
        c=inuse.cancel("Retry", "Exit", name="Retry")
        c.event("EndDialog","Retry")

# See "Error Dialog". See "ICE20" for the required names of the controls.
        error = Dialog(db, "ErrorDlg",
                       50, 10, 330, 101,
                       65543,       # Error|Minimize|Modal|Visible
                       title,
                       "ErrorText", None, None)
        error.text("ErrorText", 50,9,280,48,3, "")
        #error.control("ErrorIcon", "Icon", 15, 9, 24, 24, 5242881, None, "py.ico", None, None)
        error.pushbutton("N",120,72,81,21,3,"No",None).event("EndDialog","ErrorNo")
        error.pushbutton("Y",240,72,81,21,3,"Yes",None).event("EndDialog","ErrorYes")
        error.pushbutton("A",0,72,81,21,3,"Abort",None).event("EndDialog","ErrorAbort")
        error.pushbutton("C",42,72,81,21,3,"Cancel",None).event("EndDialog","ErrorCancel")
        error.pushbutton("I",81,72,81,21,3,"Ignore",None).event("EndDialog","ErrorIgnore")
        error.pushbutton("O",159,72,81,21,3,"Ok",None).event("EndDialog","ErrorOk")
        error.pushbutton("R",198,72,81,21,3,"Retry",None).event("EndDialog","ErrorRetry")

#####################################################################
        # Global "Query Cancel" dialog
        cancel = Dialog(db, "CancelDlg", 50, 10, 260, 85, 3, title,
                        "No", "No", "No")
        cancel.text("Text", 48, 15, 194, 30, 3,
                    "Are you sure you want to cancel [ProductName] installation?")
        #cancel.control("Icon", "Icon", 15, 15, 24, 24, 5242881, None,
        #               "py.ico", None, None)
        c=cancel.pushbutton("Yes", 72, 57, 56, 17, 3, "Yes", "No")
        c.event("EndDialog", "Exit")

c=cancel.pushbutton("No", 132, 57, 56, 17, 3, "No", "Yes")
        c.event("EndDialog", "Return")

#####################################################################
        # Global "Wait for costing" dialog
        costing = Dialog(db, "WaitForCostingDlg", 50, 10, 260, 85, modal, title,
                         "Return", "Return", "Return")
        costing.text("Text", 48, 15, 194, 30, 3,
                     "Please wait while the installer finishes determining your disk space requirements.")
        c = costing.pushbutton("Return", 102, 57, 56, 17, 3, "Return", None)
        c.event("EndDialog", "Exit")

#####################################################################
        # Preparation dialog: no user input except cancellation
        prep = PyDialog(db, "PrepareDlg", x, y, w, h, modeless, title,
                        "Cancel", "Cancel", "Cancel")
        prep.text("Description", 15, 70, 320, 40, 0x30003,
                  "Please wait while the Installer prepares to guide you through the installation.")
        prep.title("Welcome to the [ProductName] Installer")
        c=prep.text("ActionText", 15, 110, 320, 20, 0x30003, "Pondering...")
        c.mapping("ActionText", "Text")
        c=prep.text("ActionData", 15, 135, 320, 30, 0x30003, None)
        c.mapping("ActionData", "Text")
        prep.back("Back", None, active=0)
        prep.next("Next", None, active=0)
        c=prep.cancel("Cancel", None)
        c.event("SpawnDialog", "CancelDlg")

#####################################################################
        # Feature (Python directory) selection
        seldlg = PyDialog(db, "SelectFeaturesDlg", x, y, w, h, modal, title,
                        "Next", "Next", "Cancel")
        seldlg.title("Select Python Installations")

seldlg.text("Hint", 15, 30, 300, 20, 3,
                    "Select the Python locations where %s should be installed."
                    % self.distribution.get_fullname())

seldlg.back("< Back", None, active=0)
        c = seldlg.next("Next >", "Cancel")
        order = 1
        c.event("[TARGETDIR]", "[SourceDir]", ordering=order)
        for version in self.versions + [self.other_version]:
            order += 1
            c.event("[TARGETDIR]", "[TARGETDIR%s]" % version,
                    "FEATURE_SELECTED AND &Python%s=3" % version,
                    ordering=order)
        c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=order + 1)
        c.event("EndDialog", "Return", ordering=order + 2)
        c = seldlg.cancel("Cancel", "Features")
        c.event("SpawnDialog", "CancelDlg")

c = seldlg.control("Features", "SelectionTree", 15, 60, 300, 120, 3,
                           "FEATURE", None, "PathEdit", None)
        c.event("[FEATURE_SELECTED]", "1")
        ver = self.other_version
        install_other_cond = "FEATURE_SELECTED AND &Python%s=3" % ver
        dont_install_other_cond = "FEATURE_SELECTED AND &Python%s<>3" % ver

c = seldlg.text("Other", 15, 200, 300, 15, 3,
                        "Provide an alternate Python location")
        c.condition("Enable", install_other_cond)
        c.condition("Show", install_other_cond)
        c.condition("Disable", dont_install_other_cond)
        c.condition("Hide", dont_install_other_cond)

c = seldlg.control("PathEdit", "PathEdit", 15, 215, 300, 16, 1,
                           "TARGETDIR" + ver, None, "Next", None)
        c.condition("Enable", install_other_cond)
        c.condition("Show", install_other_cond)
        c.condition("Disable", dont_install_other_cond)
        c.condition("Hide", dont_install_other_cond)

#####################################################################
        # Disk cost
        cost = PyDialog(db, "DiskCostDlg", x, y, w, h, modal, title,
                        "OK", "OK", "OK", bitmap=False)
        cost.text("Title", 15, 6, 200, 15, 0x30003,
                  "{\DlgFontBold8}Disk Space Requirements")
        cost.text("Description", 20, 20, 280, 20, 0x30003,
                  "The disk space required for the installation of the selected features.")
        cost.text("Text", 20, 53, 330, 60, 3,
                  "The highlighted volumes (if any) do not have enough disk space "
              "available for the currently selected features.  You can either "
              "remove some files from the highlighted volumes, or choose to "
              "install less features onto local drive(s), or select different "
              "destination drive(s).")
        cost.control("VolumeList", "VolumeCostList", 20, 100, 330, 150, 393223,
                     None, "{120}{70}{70}{70}{70}", None, None)
        cost.xbutton("OK", "Ok", None, 0.5).event("EndDialog", "Return")

#####################################################################
        # WhichUsers Dialog. Only available on NT, and for privileged users.
        # This must be run before FindRelatedProducts, because that will
        # take into account whether the previous installation was per-user
        # or per-machine. We currently don't support going back to this
        # dialog after "Next" was selected; to support this, we would need to
        # find how to reset the ALLUSERS property, and how to re-run
        # FindRelatedProducts.
        # On Windows9x, the ALLUSERS property is ignored on the command line
        # and in the Property table, but installer fails according to the documentation
        # if a dialog attempts to set ALLUSERS.
        whichusers = PyDialog(db, "WhichUsersDlg", x, y, w, h, modal, title,
                            "AdminInstall", "Next", "Cancel")
        whichusers.title("Select whether to install [ProductName] for all users of this computer.")
        # A radio group with two options: allusers, justme
        g = whichusers.radiogroup("AdminInstall", 15, 60, 260, 50, 3,
                                  "WhichUsers", "", "Next")
        g.add("ALL", 0, 5, 150, 20, "Install for all users")
        g.add("JUSTME", 0, 25, 150, 20, "Install just for me")

whichusers.back("Back", None, active=0)

c = whichusers.next("Next >", "Cancel")
        c.event("[ALLUSERS]", "1", 'WhichUsers="ALL"', 1)
        c.event("EndDialog", "Return", ordering = 2)

c = whichusers.cancel("Cancel", "AdminInstall")
        c.event("SpawnDialog", "CancelDlg")

#####################################################################
        # Installation Progress dialog (modeless)
        progress = PyDialog(db, "ProgressDlg", x, y, w, h, modeless, title,
                            "Cancel", "Cancel", "Cancel", bitmap=False)
        progress.text("Title", 20, 15, 200, 15, 0x30003,
                      "{\DlgFontBold8}[Progress1] [ProductName]")
        progress.text("Text", 35, 65, 300, 30, 3,
                      "Please wait while the Installer [Progress2] [ProductName]. "
                      "This may take several minutes.")
        progress.text("StatusLabel", 35, 100, 35, 20, 3, "Status:")

c=progress.text("ActionText", 70, 100, w-70, 20, 3, "Pondering...")
        c.mapping("ActionText", "Text")

#c=progress.text("ActionData", 35, 140, 300, 20, 3, None)
        #c.mapping("ActionData", "Text")

c=progress.control("ProgressBar", "ProgressBar", 35, 120, 300, 10, 65537,
                           None, "Progress done", None, None)
        c.mapping("SetProgress", "Progress")

progress.back("< Back", "Next", active=False)
        progress.next("Next >", "Cancel", active=False)
        progress.cancel("Cancel", "Back").event("SpawnDialog", "CancelDlg")

###################################################################
        # Maintenance type: repair/uninstall
        maint = PyDialog(db, "MaintenanceTypeDlg", x, y, w, h, modal, title,
                         "Next", "Next", "Cancel")
        maint.title("Welcome to the [ProductName] Setup Wizard")
        maint.text("BodyText", 15, 63, 330, 42, 3,
                   "Select whether you want to repair or remove [ProductName].")
        g=maint.radiogroup("RepairRadioGroup", 15, 108, 330, 60, 3,
                            "MaintenanceForm_Action", "", "Next")
        #g.add("Change", 0, 0, 200, 17, "&Change [ProductName]")
        g.add("Repair", 0, 18, 200, 17, "&Repair [ProductName]")
        g.add("Remove", 0, 36, 200, 17, "Re&move [ProductName]")

maint.back("< Back", None, active=False)
        c=maint.next("Finish", "Cancel")
        # Change installation: Change progress dialog to "Change", then ask
        # for feature selection
        #c.event("[Progress1]", "Change", 'MaintenanceForm_Action="Change"', 1)
        #c.event("[Progress2]", "changes", 'MaintenanceForm_Action="Change"', 2)

# Reinstall: Change progress dialog to "Repair", then invoke reinstall
        # Also set list of reinstalled features to "ALL"
        c.event("[REINSTALL]", "ALL", 'MaintenanceForm_Action="Repair"', 5)
        c.event("[Progress1]", "Repairing", 'MaintenanceForm_Action="Repair"', 6)
        c.event("[Progress2]", "repairs", 'MaintenanceForm_Action="Repair"', 7)
        c.event("Reinstall", "ALL", 'MaintenanceForm_Action="Repair"', 8)

# Uninstall: Change progress to "Remove", then invoke uninstall
        # Also set list of removed features to "ALL"
        c.event("[REMOVE]", "ALL", 'MaintenanceForm_Action="Remove"', 11)
        c.event("[Progress1]", "Removing", 'MaintenanceForm_Action="Remove"', 12)
        c.event("[Progress2]", "removes", 'MaintenanceForm_Action="Remove"', 13)
        c.event("Remove", "ALL", 'MaintenanceForm_Action="Remove"', 14)

# Close dialog when maintenance action scheduled
        c.event("EndDialog", "Return", 'MaintenanceForm_Action<>"Change"', 20)
        #c.event("NewDialog", "SelectFeaturesDlg", 'MaintenanceForm_Action="Change"', 21)

maint.cancel("Cancel", "RepairRadioGroup").event("SpawnDialog", "CancelDlg")

def get_installer_filename(self, fullname):
        # Factored out to allow overriding in subclasses
        if self.target_version:
            base_name = "%s.%s-py%s.msi" % (fullname, self.plat_name,
                                            self.target_version)
        else:
            base_name = "%s.%s.msi" % (fullname, self.plat_name)
        installer_name = os.path.join(self.dist_dir, base_name)
        return installer_name
command/bdist_msi.pyc000064400000056631151702014350010665 0ustar00�
{fc@sdZddlZddlZddlmZddlmZddlmZddl	m
Z
ddlmZddl
mZdd	lmZddlZdd
lmZmZmZddlmZmZmZmZdefd
��YZdefd��YZdS(s#
Implements the bdist_msi command.
i����N(tget_python_version(tCommand(tremove_tree(t
StrictVersion(tDistutilsOptionError(tlog(tget_platform(tschematsequencettext(t	DirectorytFeaturetDialogtadd_datatPyDialogcBsVeZdZd�Zd�Zddd�Zddd�Zddd	�Zd
�ZRS(s�Dialog class with a fixed layout: controls at the top, then a ruler,
    then a list of buttons: back, next, cancel. Optionally a bitmap at the
    left.cOs=tj||�|jd}|jdd||jd�dS(sbDialog(database, name, x, y, w, h, attributes, title, first,
        default, cancel, bitmap=true)i$t
BottomLineiN(Rt__init__thtlinetw(tselftargstkwtruler((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyRs
c	Cs'|jddddddd|�dS(	s,Set the title text of the dialog at the top.tTitleii
i@i<is{\VerdanaBold10}%sN(R	(Rttitle((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR$stBackic	Cs>|rd}nd}|j|d|jddd|||�S(s�Add a back button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

Return the button, so that events can be associatediii�ii8i(t
pushbuttonR(RRtnexttnametactivetflags((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pytback+s	tCancelc	Cs>|rd}nd}|j|d|jddd|||�S(s�Add a cancel button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

Return the button, so that events can be associatediii0ii8i(RR(RRRRRR((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pytcancel6s	tNextc	Cs>|rd}nd}|j|d|jddd|||�S(s�Add a Next button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

Return the button, so that events can be associatediii�ii8i(RR(RRRRRR((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyRAs	c	Cs:|j|t|j|d�|jdddd||�S(s�Add a button with a given title, the tab-next button,
        its name in the Control table, giving its x position; the
        y-position is aligned with the other buttons.

Return the button, so that events can be associatediii8ii(RtintRR(RRRRtxpos((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pytxbuttonLs(	t__name__t
__module__t__doc__RRR R"RR&(((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyRs			t	bdist_msicBs=eZdZdedfddde�fdddd	fd
eddfd
ddfdddfdddfdedfdedfdedfg
Zdd
ddgZddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/gZd0Zd1�Z	d2�Z
d3�Zd4�Zd5�Z
d6�Zd7�Zd8�ZRS(9s7create a Microsoft Installer (.msi) binary distributions
bdist-dir=s1temporary directory for creating the distributions
plat-name=tps;platform name to embed in generated filenames (default: %s)s	keep-temptks/keep the pseudo-installation tree around after s!creating the distribution archivestarget-version=s!require a specific python versions on the target systemsno-target-compiletcs/do not compile .py to .pyc on the target systemsno-target-optimizetos;do not compile .py to .pyo (optimized) on the target systems	dist-dir=tds-directory to put final built distributions ins
skip-builds2skip rebuilding everything (for testing/debugging)sinstall-script=sUbasename of installation script to be run after installation or before deinstallationspre-install-script=s{Fully qualified filename of a script to be run before any files are installed.  This script need not be in the distributions2.0s2.1s2.2s2.3s2.4s2.5s2.6s2.7s2.8s2.9s3.0s3.1s3.2s3.3s3.4s3.5s3.6s3.7s3.8s3.9tXcCsgd|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_dS(Ni(tNonet	bdist_dirt	plat_namet	keep_temptno_target_compiletno_target_optimizettarget_versiontdist_dirt
skip_buildtinstall_scripttpre_install_scripttversions(R((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pytinitialize_options~s										cCsi|jdd	�|jdkrL|jd�j}tjj|d�|_nt�}|j	rz|j
j�rz||_	n|j	r�|j	g|_|j
r�|j
j�r�|j	|kr�td|f�q�nt|j�|_|jdd
d�|jr
td�n|jr\xF|j
jD]%}|jtjj|�kr Pq q Wtd|j�nd|_dS(NtbdistR9tmsisMtarget version can only be %s, or the '--skip-build' option must be specifiedR8R3s5the pre-install-script feature is not yet implementeds(install_script '%s' not found in scripts(R9R9(R8R8(R3R3(tset_undefined_optionsR2R1tget_finalized_commandt
bdist_basetostpathtjoinRR7tdistributionthas_ext_modulesR<R9Rtlisttall_versionsR;R:tscriptstbasenametinstall_script_key(RRBt
short_versiontscript((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pytfinalize_options�s8					
cCs�|js|jd�n|jddd�}|j|_|j|_d|_|jd�}d|_d|_|jj	�r�|j
}|s�|js�td��tj
dd!}nd	|j|f}|jd�}tjj|jd
|�|_ntjd|j�|j�tjjdtjj|jd��|j�tjd=|j|j�|jj�}|j|�}tjj|�}tjj|�r�tj |�n|jj!}|j"}	|	s�|j#}	n|	s�d
}	n|j$�}
dt%|
�j
}|jj�}|j
r5d|j
|f}n
d|}t&j'|t(|t&j)�||	�|_*t&j+|j*t,�d|
fg}
|j-p�|j.}|r�|
j/d|f�n|j0r�|
j/d|j0f�n|
r�t1|j*d|
�n|j2�|j3�|j4�|j5�|j*j6�t7|jd�rid|j
pJd|f}|jj8j/|�n|j9s�t:|jd|j;�ndS(Ntbuildtinstalltreinit_subcommandsiitinstall_libs Should have already checked thisis.%s-%stlibsinstalling to %stPURELIBtUNKNOWNs%d.%d.%dsPython %s %ss	Python %stDistVersiont
ARPCONTACTtARPURLINFOABOUTtPropertyt
dist_filesR*tanytdry_run(<R9trun_commandtreinitialize_commandR2tprefixtwarn_dirtcompiletoptimizeRFRGR7tAssertionErrortsystversionR3RARCRDREt
build_baset	build_libRtinfotensure_finalizedtinserttruntmkpathR8tget_fullnametget_installer_filenametabspathtexiststunlinktmetadatatauthort
maintainertget_versionRtmsilibt
init_databaseRtgen_uuidtdbt
add_tablesRtauthor_emailtmaintainer_emailtappendturlR
tadd_find_pythont	add_filestadd_scriptstadd_uitCommitthasattrR[R4RR](RRQRSR7tplat_specifierRPtfullnametinstaller_nameRsRtRftsversiontproduct_nametpropstemailttup((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyRl�s~					
%

c
Cs�|j}tjd�}tjj|j�}t||d|dd�}t	|ddddddd�}||d	fg}x�|j
|jgD]�}d|}d|}	}
d}||jkr�d
}d}
nd|}d}
t	||	||d|
d|�}t||||||
�}|j|||f�q�W|j
�i}x�|D]�\}}}|g}xg|r�|j�}xNtj|j�D]:}tjj|j|�}tjj|�rd
|j|�|f}||}
t|||||
|�}|j|�q�|js.|j|j|d�n||kr�|j|�}||<||jkr�|jr|td|��nd||_q�q�||}t|jd|||j|d|jfg�q�WqiW|j
�qNW|j|�dS(Nt	distfilest	TARGETDIRt	SourceDirtPythont
Everythingiit	directorytsPython from another locationisPython %s from registrys%s|%ssMultiple files with name %ss[#%s]t
DuplicateFile(RzRwtCABRCRDRpR2R
R1RR<t
other_versionR~R�tpoptlistdirtabsoluteREtisdirt
make_shortt	componenttstart_componenttlogicaltadd_fileR:RLRR
tcommit(RRztcabtrootdirtroottftitemsRfttargetRtdefaulttdescRtleveltdirtseentfeaturettodotfiletafiletshorttnewdirtkey((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR�s\	
	
!
		
		
+cCsd}x|jD]�}d|}d|}d|}d|}d|}d|}d|}	d	|}
d
|}d|}tjr�d }
nd}
t|jd|d|d|
f|d|d|
fg�t|jd||f||fg�t|jd|d!|d|df|	d"|d|df|
d#|d|dfg�t|jd|||f|	||df|
d|dfg�t|jd|||f|	||df|
d|dfg�t|jdd|dd|fg�|d7}|dkst�qWdS($ssAdds code to the installer to compute the location of Python.

Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
        registry for each version of Python.

Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
        else from PYTHON.MACHINE.X.Y.

Properties PYTHONX.Y will be set to TARGETDIRX.Y\python.exei�s)SOFTWARE\Python\PythonCore\%s\InstallPathspython.machine.spython.user.sPYTHON.MACHINE.sPYTHON.USER.tPythonFromMachinetPythonFromUsert	PythonExeR�tPYTHONiit
RegLocatorit	AppSearchtCustomActioni3it[t]s]\python.exetInstallExecuteSequencetInstallUISequencet	ConditionR�is
NOT TARGETDIRii�Nii3i3i3(R<RwtWin64R
RzR1Rd(Rtstarttvertinstall_pathtmachine_regtuser_regtmachine_propt	user_proptmachine_actiontuser_actiont
exe_actionttarget_dir_proptexe_proptType((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR�EsJ

cCsQ|jr�d}x�|j|jgD]l}d|}d|}t|jd|d||jfg�t|jd|d||fg�|d7}q#Wn|jrMtjj	|j
d	�}t|d
�}|jd�|jt|j�j
��|j�t|jdd
tj|�fg�t|jddg�t|jddg�ndS(Ni�sinstall_script.R�R�i2R�s&Python%s=3ispreinstall.batRsrem ="""
%1 %0
exit
"""
tBinaryt
PreInstallis
NOT Installedi�(R�iR�N(R�s
NOT Installedi�(R:R<R�R
RzRLR;RCRDRER2topentwritetreadtcloseRwR�R1(RR�R�tinstall_actionR�tscriptfnR�((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR�{s,

cCsA|j}d}}d}d}d}d}d}t|dd�d�d�d�d�d�g�t|dd�d�d�d�g�t|dd�d�d�d�d�g�t|d.tj�t|d/tj�t|d0||||||d1d1d1�}	|	jd2�|	jd3d1d4d�|	j	d5d6d4d�|	jd7d8d9d:d;d<d=�|	jd>d8d?d:d@d<dA�|	j
d1d5dBd1�}
|
jdCdD�t|dE||||||d1d1d1�}|jdF�|jd3d1d4d�|j	d5d6d4d�|jd7d8d9d:d;d<dG�|jd>d8d?d:d@d<dA�|j
d1d5dBd1�}
|
jdCdD�t|dH||||||d1d1d1�}|jdI�|jd3d1d4d�|j	d5d6d4d�|jdJd8dKd:d@d<dA�|j
d1d5dBd1�}
|
jdCdL�t|dM||||dN|dOdOdOdPt�}
|
jdQd8dRdSd8d<dT�|
jdJd@dUdVd@d<dW�|
jdXd@dYdZddd[�|
j
d\d]d@d^dZd_d`daddd�|
jdDdbdBdD�}
|
jdCdD�|
j
dbdOdBdb�}
|
jdCdb�|
j	dOdDdBdO�}
|
jdCdO�t|ddddZdcdd|dedd�}|jdedddVdfddg�|jdhdidjdkdlddmd�jdCdn�|jdodpdjdkdlddqd�jdCdr�|jdsddjdkdlddtd�jdCdu�|jdvdwdjdkdldd5d�jdCdx�|jdydkdjdkdlddbd�jdCdz�|jd{d|djdkdldd}d�jdCd~�|jdd�djdkdlddOd�jdCd��t|d�ddd�d�d|dmdmdm�}|jdXdfd8d�d�dd��|jdqdjd�d�d�ddqdm�}
|
jdCdD�|jdmd�d�d�d�ddmdq�}
|
jdCdL�t|d�ddd�d�||dLdLdL�}|jdXdfd8d�d�dd��|jdLd�d�d�d�ddLd�}
|
jdCdD�t|d ||||||d5d5d5�}|jdJd8d9d:d�d<d��|jd��|jd.d8d�d:d@d<d��}
|
jd.dX�|jd�d8d�d:d�d<d�}
|
jd�dX�|jd6dd4d�|j
d�dd4d�|j	d5d�}
|
jd�d��t|d&||||||d�d�d5�}|jd��|jd�d8d�dd@dd�|jj��|jd3dd4d�|j
d�d5�}
d}|
jd�d�d�|�xF|j|jgD]1}|d7}|
jd�d�|d�|d�|�q�W|
jd�d�d�|d�|
jdCdLd�|d��|j	d5d��}
|
jd�d��|j
d�d�d8d�ddidd�dd�d�}
|
jd�d��|j}d�|}d�|}|jd�d8dSdd8dd��}
|
jd�|�|
jd�|�|
jd�|�|
jd�|�|j
d�d�d8d�dd�dd�|dd�d�}
|
jd�|�|
jd�|�|
jd�|�|
jd�|�t|d�||||||d�d�d�dPt�}|jdQd8dRdSd8d<d��|jdJd@d@dVd@d<d��|jdXd@d�dZd�dd��|j
d�d�d@d�dZd�d�dd�dd�|jd�d}dd��jdCdL�t|d#||||||d�d�d5�}|jd��|jd�d8d�d�ddddgd��	}|jddd�d�d@d��|jd�dd�d�d@d��|jd6dd4d�|j
d�d5�}
|
jd�d�d�d�|
jdCdLd�d��|j	d5d��}
|
jd�d��t|d,||||||d5d5d5dPt�}|jdQd@d8dSd8d<d��|jdXd�d�dd�dd��|jd�d�d�d�d@dd��|jd.d9d�|d9d@dd��}
|
jd.dX�|j
d�d�d�diddd�dd�dd�}
|
jd�d��|jd3d�d4t�|j
d�d5d4t�|j	d5d6�jd�d��t|d)||||||d�d�d5�}|jd��|jd�d8d�dZdwdd��|jd�d8d�dZd�dddgd��	}|jddd�dSd�d��|jd�dd�dSd�d��|jd3dd4t�|j
d1d5�}
|
jd�dd�d��|
jd�d�d�dR�|
jd�d�d�d`�|
jd�dd�d�|
jd�dd�d��|
jd�d�d�d��|
jd�d�d�d��|
jd�dd�d��|
jdCdLd�d@�|j	d5d��jd�d��dS(�Ni2iri,s[ProductName] SetupiiRZt
DefaultUIFonttDlgFont8tErrorDialogtErrorDlgt	Progress1tInstallt	Progress2tinstallstMaintenanceForm_ActiontRepairt
WhichUserstALLt	TextStyletTahomai	itDlgFontBold8it
VerdanaBold10tVerdanai
tVerdanaRed9i�R�t
PrepareDlgs(Not Privileged or Windows9x or Installedi�t
WhichUsersDlgs.Privileged and not Windows9x and not Installedi�tSelectFeaturesDlgs
Not Installedi�tMaintenanceTypeDlgs,Installed AND NOT RESUME AND NOT Preselectedi�tProgressDlgit
ActionTexttUITextt
FatalErrortFinishs)[ProductName] Installer ended prematurelys< BackRR!RtDescription1iiFi@iPis�[ProductName] setup ended prematurely because of an error.  Your system has not been modified.  To install this program at a later time, please run the installation again.tDescription2i�is.Click the Finish button to exit the Installer.Rt	EndDialogtExittUserExits'[ProductName] Installer was interrupteds�[ProductName] setup was interrupted.  Your system has not been modified.  To install this program at a later time, please run the installation again.t
ExitDialogs&Completing the [ProductName] InstallertDescriptioni�tReturnt
FilesInUseitRetrytbitmapRii�s{\DlgFontBold8}Files in Useiis8Some files that need to be updated are currently in use.tTexti7iJs�The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.tListtListBoxiki�itFileInUseProcesstIgnoreieit	ErrorTexti0R�tNixiHiQitNotErrorNotYi�tYestErrorYestAtAbortt
ErrorAborttCi*tErrorCanceltItErrorIgnoretOi�tOktErrorOktRi�t
ErrorRetryt	CancelDlgiiUi�is;Are you sure you want to cancel [ProductName] installation?i9i8ii�tWaitForCostingDlgsRPlease wait while the installer finishes determining your disk space requirements.ifi(sOPlease wait while the Installer prepares to guide you through the installation.s&Welcome to the [ProductName] InstallerinsPondering...t
ActionDatai�R#tSpawnDialogsSelect Python InstallationstHints9Select the Python locations where %s should be installed.sNext >s[TARGETDIR]s[SourceDir]torderings
[TARGETDIR%s]s FEATURE_SELECTED AND &Python%s=3tSpawnWaitDialogitFeaturest
SelectionTreei<tFEATUREtPathEdits[FEATURE_SELECTED]t1s!FEATURE_SELECTED AND &Python%s<>3tOthers$Provide an alternate Python locationtEnabletShowtDisabletHidei�iR�tDiskCostDlgtOKs&{\DlgFontBold8}Disk Space RequirementssFThe disk space required for the installation of the selected features.i5sThe highlighted volumes (if any) do not have enough disk space available for the currently selected features.  You can either remove some files from the highlighted volumes, or choose to install less features onto local drive(s), or select different destination drive(s).t
VolumeListtVolumeCostListidi�is{120}{70}{70}{70}{70}g�?tAdminInstallsGSelect whether to install [ProductName] for all users of this computer.isInstall for all userstJUSTMEisInstall just for mes
[ALLUSERS]sWhichUsers="ALL"s({\DlgFontBold8}[Progress1] [ProductName]i#iAsYPlease wait while the Installer [Progress2] [ProductName]. This may take several minutes.tStatusLabelsStatus:tProgressBaris
Progress donetSetProgresstProgresss)Welcome to the [ProductName] Setup WizardtBodyTexti?s:Select whether you want to repair or remove [ProductName].tRepairRadioGroupilis&Repair [ProductName]tRemovei$sRe&move [ProductName]s[REINSTALL]sMaintenanceForm_Action="Repair"s[Progress1]t	Repairings[Progress2]trepairst	Reinstalls[REMOVE]sMaintenanceForm_Action="Remove"itRemovingitremovesi
is MaintenanceForm_Action<>"Change"(R�R�(R�R�(R�R�(R�R�(R�R�(R�R�(R�R�i	Ni(R�R�iNi(R�R�i
Ni(R�R�i	i�i(R�s(Not Privileged or Windows9x or Installedi�(R�s.Privileged and not Windows9x and not Installedi�(R�s
Not Installedi�(R�s,Installed AND NOT RESUME AND NOT Preselectedi�(R�Ni(RzR
R1R	R�R�RRR R"RteventtFalsetcontrolRRtmappingRFRnR<R�t	conditionR&t
radiogrouptadd(RRztxtyRRRtmodaltmodelesstfatalR-t	user_exittexit_dialogtinuseterrorR"tcostingtpreptseldlgtorderRfR�tinstall_other_condtdont_install_other_condtcostt
whichuserstgtprogresstmaint((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR��s�

.......$$$
!!

%
cCsT|jr%d||j|jf}nd||jf}tjj|j|�}|S(Ns%s.%s-py%s.msis	%s.%s.msi(R7R3RCRDRER8(RR�t	base_nameR�((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyRo�s	(R'R(tdescriptionR1Rtuser_optionstboolean_optionsRIR�R=RORlR�R�R�R�Ro(((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR*TsP
			
	)	[	6	6	&	�>(R)ReRCt	sysconfigRtdistutils.coreRtdistutils.dir_utilRtdistutils.versionRtdistutils.errorsRt	distutilsRtdistutils.utilRRwRRR	R
RRR
RR*(((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyt<module>s"=command/bdist_msi.pyo000064400000056456151702014350010706 0ustar00�
{fc@sdZddlZddlZddlmZddlmZddlmZddl	m
Z
ddlmZddl
mZdd	lmZddlZdd
lmZmZmZddlmZmZmZmZdefd
��YZdefd��YZdS(s#
Implements the bdist_msi command.
i����N(tget_python_version(tCommand(tremove_tree(t
StrictVersion(tDistutilsOptionError(tlog(tget_platform(tschematsequencettext(t	DirectorytFeaturetDialogtadd_datatPyDialogcBsVeZdZd�Zd�Zddd�Zddd�Zddd	�Zd
�ZRS(s�Dialog class with a fixed layout: controls at the top, then a ruler,
    then a list of buttons: back, next, cancel. Optionally a bitmap at the
    left.cOs=tj||�|jd}|jdd||jd�dS(sbDialog(database, name, x, y, w, h, attributes, title, first,
        default, cancel, bitmap=true)i$t
BottomLineiN(Rt__init__thtlinetw(tselftargstkwtruler((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyRs
c	Cs'|jddddddd|�dS(	s,Set the title text of the dialog at the top.tTitleii
i@i<is{\VerdanaBold10}%sN(R	(Rttitle((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR$stBackic	Cs>|rd}nd}|j|d|jddd|||�S(s�Add a back button with a given title, the tab-next button,
        its name in the Control table, possibly initially disabled.

Return the button, so that events can be associatediii8ii(RtintRR(RRRRtxpos((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pytxbuttonLs(	t__name__t
__module__t__doc__RRR R"RR&(((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyRs			t	bdist_msicBs=eZdZdedfddde�fdddd	fd
eddfd
ddfdddfdddfdedfdedfdedfg
Zdd
ddgZddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/gZd0Zd1�Z	d2�Z
d3�Zd4�Zd5�Z
d6�Zd7�Zd8�ZRS(9s7create a Microsoft Installer (.msi) binary distributions
bdist-dir=s1temporary directory for creating the distributions
plat-name=tps;platform name to embed in generated filenames (default: %s)s	keep-temptks/keep the pseudo-installation tree around after s!creating the distribution archivestarget-version=s!require a specific python versions on the target systemsno-target-compiletcs/do not compile .py to .pyc on the target systemsno-target-optimizetos;do not compile .py to .pyo (optimized) on the target systems	dist-dir=tds-directory to put final built distributions ins
skip-builds2skip rebuilding everything (for testing/debugging)sinstall-script=sUbasename of installation script to be run after installation or before deinstallationspre-install-script=s{Fully qualified filename of a script to be run before any files are installed.  This script need not be in the distributions2.0s2.1s2.2s2.3s2.4s2.5s2.6s2.7s2.8s2.9s3.0s3.1s3.2s3.3s3.4s3.5s3.6s3.7s3.8s3.9tXcCsgd|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_dS(Ni(tNonet	bdist_dirt	plat_namet	keep_temptno_target_compiletno_target_optimizettarget_versiontdist_dirt
skip_buildtinstall_scripttpre_install_scripttversions(R((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pytinitialize_options~s										cCsi|jdd	�|jdkrL|jd�j}tjj|d�|_nt�}|j	rz|j
j�rz||_	n|j	r�|j	g|_|j
r�|j
j�r�|j	|kr�td|f�q�nt|j�|_|jdd
d�|jr
td�n|jr\xF|j
jD]%}|jtjj|�kr Pq q Wtd|j�nd|_dS(NtbdistR9tmsisMtarget version can only be %s, or the '--skip-build' option must be specifiedR8R3s5the pre-install-script feature is not yet implementeds(install_script '%s' not found in scripts(R9R9(R8R8(R3R3(tset_undefined_optionsR2R1tget_finalized_commandt
bdist_basetostpathtjoinRR7tdistributionthas_ext_modulesR<R9Rtlisttall_versionsR;R:tscriptstbasenametinstall_script_key(RRBt
short_versiontscript((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pytfinalize_options�s8					
cCsz|js|jd�n|jddd�}|j|_|j|_d|_|jd�}d|_d|_|jj	�r�|j
}|s�tjdd!}nd|j
|f}|jd�}tjj|jd	|�|_ntjd
|j�|j�tjjdtjj|jd��|j�tjd=|j|j�|jj�}|j|�}tjj|�}tjj|�r�tj|�n|jj }|j!}	|	s�|j"}	n|	s�d}	n|j#�}
d
t$|
�j}|jj�}|j
r d|j
|f}n
d|}t%j&|t'|t%j(�||	�|_)t%j*|j)t+�d|
fg}
|j,p�|j-}|r�|
j.d|f�n|j/r�|
j.d|j/f�n|
r�t0|j)d|
�n|j1�|j2�|j3�|j4�|j)j5�t6|jd�rTd|j
p5d|f}|jj7j.|�n|j8svt9|jd|j:�ndS(Ntbuildtinstalltreinit_subcommandsiitinstall_libis.%s-%stlibsinstalling to %stPURELIBtUNKNOWNs%d.%d.%dsPython %s %ss	Python %stDistVersiont
ARPCONTACTtARPURLINFOABOUTtPropertyt
dist_filesR*tanytdry_run(;R9trun_commandtreinitialize_commandR2tprefixtwarn_dirtcompiletoptimizeRFRGR7tsystversionR3RARCRDREt
build_baset	build_libRtinfotensure_finalizedtinserttruntmkpathR8tget_fullnametget_installer_filenametabspathtexiststunlinktmetadatatauthort
maintainertget_versionRtmsilibt
init_databaseRtgen_uuidtdbt
add_tablesRtauthor_emailtmaintainer_emailtappendturlR
tadd_find_pythont	add_filestadd_scriptstadd_uitCommitthasattrR[R4RR](RRQRSR7tplat_specifierRPtfullnametinstaller_nameRrRsRetsversiontproduct_nametpropstemailttup((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyRk�s|					
%

c
Cs�|j}tjd�}tjj|j�}t||d|dd�}t	|ddddddd�}||d	fg}x�|j
|jgD]�}d|}d|}	}
d}||jkr�d
}d}
nd|}d}
t	||	||d|
d|�}t||||||
�}|j|||f�q�W|j
�i}x�|D]�\}}}|g}xg|r�|j�}xNtj|j�D]:}tjj|j|�}tjj|�rd
|j|�|f}||}
t|||||
|�}|j|�q�|js.|j|j|d�n||kr�|j|�}||<||jkr�|jr|td|��nd||_q�q�||}t|jd|||j|d|jfg�q�WqiW|j
�qNW|j|�dS(Nt	distfilest	TARGETDIRt	SourceDirtPythont
Everythingiit	directorytsPython from another locationisPython %s from registrys%s|%ssMultiple files with name %ss[#%s]t
DuplicateFile(RyRvtCABRCRDRoR2R
R1RR<t
other_versionR}R�tpoptlistdirtabsoluteREtisdirt
make_shortt	componenttstart_componenttlogicaltadd_fileR:RLRR
tcommit(RRytcabtrootdirtroottftitemsRettargetRtdefaulttdescRtleveltdirtseentfeaturettodotfiletafiletshorttnewdirtkey((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR�s\	
	
!
		
		
+cCs�d}x�|jD]�}d|}d|}d|}d|}d|}d|}d|}	d	|}
d
|}d|}tjr�d}
nd}
t|jd|d|d|
f|d|d|
fg�t|jd||f||fg�t|jd|d |d|df|	d!|d|df|
d"|d|dfg�t|jd|||f|	||df|
d|dfg�t|jd|||f|	||df|
d|dfg�t|jdd|dd|fg�|d7}qWdS(#ssAdds code to the installer to compute the location of Python.

Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the
        registry for each version of Python.

Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined,
        else from PYTHON.MACHINE.X.Y.

Properties PYTHONX.Y will be set to TARGETDIRX.Y\python.exei�s)SOFTWARE\Python\PythonCore\%s\InstallPathspython.machine.spython.user.sPYTHON.MACHINE.sPYTHON.USER.tPythonFromMachinetPythonFromUsert	PythonExeR�tPYTHONiit
RegLocatorit	AppSearchtCustomActioni3it[t]s]\python.exetInstallExecuteSequencetInstallUISequencet	ConditionR�is
NOT TARGETDIRiNii3i3i3(R<RvtWin64R
RyR1(Rtstarttvertinstall_pathtmachine_regtuser_regtmachine_propt	user_proptmachine_actiontuser_actiont
exe_actionttarget_dir_proptexe_proptType((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyREsJ

cCsQ|jr�d}x�|j|jgD]l}d|}d|}t|jd|d||jfg�t|jd|d||fg�|d7}q#Wn|jrMtjj	|j
d	�}t|d
�}|jd�|jt|j�j
��|j�t|jdd
tj|�fg�t|jddg�t|jddg�ndS(Ni�sinstall_script.R�R�i2R�s&Python%s=3ispreinstall.batRsrem ="""
%1 %0
exit
"""
tBinaryt
PreInstallis
NOT Installedi�(R�iR�N(R�s
NOT Installedi�(R:R<R�R
RyRLR;RCRDRER2topentwritetreadtcloseRvR�R1(RR�R�tinstall_actionR�tscriptfnR�((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR�{s,

cCsA|j}d}}d}d}d}d}d}t|dd�d�d�d�d�d�g�t|dd�d�d�d�g�t|dd�d�d�d�d�g�t|d.tj�t|d/tj�t|d0||||||d1d1d1�}	|	jd2�|	jd3d1d4d�|	j	d5d6d4d�|	jd7d8d9d:d;d<d=�|	jd>d8d?d:d@d<dA�|	j
d1d5dBd1�}
|
jdCdD�t|dE||||||d1d1d1�}|jdF�|jd3d1d4d�|j	d5d6d4d�|jd7d8d9d:d;d<dG�|jd>d8d?d:d@d<dA�|j
d1d5dBd1�}
|
jdCdD�t|dH||||||d1d1d1�}|jdI�|jd3d1d4d�|j	d5d6d4d�|jdJd8dKd:d@d<dA�|j
d1d5dBd1�}
|
jdCdL�t|dM||||dN|dOdOdOdPt�}
|
jdQd8dRdSd8d<dT�|
jdJd@dUdVd@d<dW�|
jdXd@dYdZddd[�|
j
d\d]d@d^dZd_d`daddd�|
jdDdbdBdD�}
|
jdCdD�|
j
dbdOdBdb�}
|
jdCdb�|
j	dOdDdBdO�}
|
jdCdO�t|ddddZdcdd|dedd�}|jdedddVdfddg�|jdhdidjdkdlddmd�jdCdn�|jdodpdjdkdlddqd�jdCdr�|jdsddjdkdlddtd�jdCdu�|jdvdwdjdkdldd5d�jdCdx�|jdydkdjdkdlddbd�jdCdz�|jd{d|djdkdldd}d�jdCd~�|jdd�djdkdlddOd�jdCd��t|d�ddd�d�d|dmdmdm�}|jdXdfd8d�d�dd��|jdqdjd�d�d�ddqdm�}
|
jdCdD�|jdmd�d�d�d�ddmdq�}
|
jdCdL�t|d�ddd�d�||dLdLdL�}|jdXdfd8d�d�dd��|jdLd�d�d�d�ddLd�}
|
jdCdD�t|d ||||||d5d5d5�}|jdJd8d9d:d�d<d��|jd��|jd.d8d�d:d@d<d��}
|
jd.dX�|jd�d8d�d:d�d<d�}
|
jd�dX�|jd6dd4d�|j
d�dd4d�|j	d5d�}
|
jd�d��t|d&||||||d�d�d5�}|jd��|jd�d8d�dd@dd�|jj��|jd3dd4d�|j
d�d5�}
d}|
jd�d�d�|�xF|j|jgD]1}|d7}|
jd�d�|d�|d�|�q�W|
jd�d�d�|d�|
jdCdLd�|d��|j	d5d��}
|
jd�d��|j
d�d�d8d�ddidd�dd�d�}
|
jd�d��|j}d�|}d�|}|jd�d8dSdd8dd��}
|
jd�|�|
jd�|�|
jd�|�|
jd�|�|j
d�d�d8d�dd�dd�|dd�d�}
|
jd�|�|
jd�|�|
jd�|�|
jd�|�t|d�||||||d�d�d�dPt�}|jdQd8dRdSd8d<d��|jdJd@d@dVd@d<d��|jdXd@d�dZd�dd��|j
d�d�d@d�dZd�d�dd�dd�|jd�d}dd��jdCdL�t|d#||||||d�d�d5�}|jd��|jd�d8d�d�ddddgd��	}|jddd�d�d@d��|jd�dd�d�d@d��|jd6dd4d�|j
d�d5�}
|
jd�d�d�d�|
jdCdLd�d��|j	d5d��}
|
jd�d��t|d,||||||d5d5d5dPt�}|jdQd@d8dSd8d<d��|jdXd�d�dd�dd��|jd�d�d�d�d@dd��|jd.d9d�|d9d@dd��}
|
jd.dX�|j
d�d�d�diddd�dd�dd�}
|
jd�d��|jd3d�d4t�|j
d�d5d4t�|j	d5d6�jd�d��t|d)||||||d�d�d5�}|jd��|jd�d8d�dZdwdd��|jd�d8d�dZd�dddgd��	}|jddd�dSd�d��|jd�dd�dSd�d��|jd3dd4t�|j
d1d5�}
|
jd�dd�d��|
jd�d�d�dR�|
jd�d�d�d`�|
jd�dd�d�|
jd�dd�d��|
jd�d�d�d��|
jd�d�d�d��|
jd�dd�d��|
jdCdLd�d@�|j	d5d��jd�d��dS(�Ni2iri,s[ProductName] SetupiiRZt
DefaultUIFonttDlgFont8tErrorDialogtErrorDlgt	Progress1tInstallt	Progress2tinstallstMaintenanceForm_ActiontRepairt
WhichUserstALLt	TextStyletTahomai	itDlgFontBold8it
VerdanaBold10tVerdanai
tVerdanaRed9i�R�t
PrepareDlgs(Not Privileged or Windows9x or Installedi�t
WhichUsersDlgs.Privileged and not Windows9x and not Installedi�tSelectFeaturesDlgs
Not Installedi�tMaintenanceTypeDlgs,Installed AND NOT RESUME AND NOT Preselectedi�tProgressDlgit
ActionTexttUITextt
FatalErrortFinishs)[ProductName] Installer ended prematurelys< BackRR!RtDescription1iiFi@iPis�[ProductName] setup ended prematurely because of an error.  Your system has not been modified.  To install this program at a later time, please run the installation again.tDescription2i�is.Click the Finish button to exit the Installer.Rt	EndDialogtExittUserExits'[ProductName] Installer was interrupteds�[ProductName] setup was interrupted.  Your system has not been modified.  To install this program at a later time, please run the installation again.t
ExitDialogs&Completing the [ProductName] InstallertDescriptioni�tReturnt
FilesInUseitRetrytbitmapRii�s{\DlgFontBold8}Files in Useiis8Some files that need to be updated are currently in use.tTexti7iJs�The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.tListtListBoxiki�itFileInUseProcesstIgnoreieit	ErrorTexti0R�tNixiHiQitNotErrorNotYi�tYestErrorYestAtAbortt
ErrorAborttCi*tErrorCanceltItErrorIgnoretOi�tOktErrorOktRi�t
ErrorRetryt	CancelDlgiiUi�is;Are you sure you want to cancel [ProductName] installation?i9i8ii�tWaitForCostingDlgsRPlease wait while the installer finishes determining your disk space requirements.ifi(sOPlease wait while the Installer prepares to guide you through the installation.s&Welcome to the [ProductName] InstallerinsPondering...t
ActionDatai�R#tSpawnDialogsSelect Python InstallationstHints9Select the Python locations where %s should be installed.sNext >s[TARGETDIR]s[SourceDir]torderings
[TARGETDIR%s]s FEATURE_SELECTED AND &Python%s=3tSpawnWaitDialogitFeaturest
SelectionTreei<tFEATUREtPathEdits[FEATURE_SELECTED]t1s!FEATURE_SELECTED AND &Python%s<>3tOthers$Provide an alternate Python locationtEnabletShowtDisabletHidei�iR�tDiskCostDlgtOKs&{\DlgFontBold8}Disk Space RequirementssFThe disk space required for the installation of the selected features.i5sThe highlighted volumes (if any) do not have enough disk space available for the currently selected features.  You can either remove some files from the highlighted volumes, or choose to install less features onto local drive(s), or select different destination drive(s).t
VolumeListtVolumeCostListidi�is{120}{70}{70}{70}{70}g�?tAdminInstallsGSelect whether to install [ProductName] for all users of this computer.isInstall for all userstJUSTMEisInstall just for mes
[ALLUSERS]sWhichUsers="ALL"s({\DlgFontBold8}[Progress1] [ProductName]i#iAsYPlease wait while the Installer [Progress2] [ProductName]. This may take several minutes.tStatusLabelsStatus:tProgressBaris
Progress donetSetProgresstProgresss)Welcome to the [ProductName] Setup WizardtBodyTexti?s:Select whether you want to repair or remove [ProductName].tRepairRadioGroupilis&Repair [ProductName]tRemovei$sRe&move [ProductName]s[REINSTALL]sMaintenanceForm_Action="Repair"s[Progress1]t	Repairings[Progress2]trepairst	Reinstalls[REMOVE]sMaintenanceForm_Action="Remove"itRemovingitremovesi
is MaintenanceForm_Action<>"Change"(R�R�(R�R�(R�R�(R�R�(R�R�(R�R�(R�R�i	Ni(R�R�iNi(R�R�i
Ni(R�R�i	i�i(R�s(Not Privileged or Windows9x or Installedi�(R�s.Privileged and not Windows9x and not Installedi�(R�s
Not Installedi�(R�s,Installed AND NOT RESUME AND NOT Preselectedi�(R�Ni(RyR
R1R	R�R�RRR R"RteventtFalsetcontrolRRtmappingRFRmR<R�t	conditionR&t
radiogrouptadd(RRytxtyRRRtmodaltmodelesstfatalR-t	user_exittexit_dialogtinuseterrorR"tcostingtpreptseldlgtorderReR�tinstall_other_condtdont_install_other_condtcostt
whichuserstgtprogresstmaint((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR��s�

.......$$$
!!

%
cCsT|jr%d||j|jf}nd||jf}tjj|j|�}|S(Ns%s.%s-py%s.msis	%s.%s.msi(R7R3RCRDRER8(RR�t	base_nameR�((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyRn�s	(R'R(tdescriptionR1Rtuser_optionstboolean_optionsRIR�R=RORkR�RR�R�Rn(((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyR*TsP
			
	)	[	6	6	&	�>(R)RdRCt	sysconfigRtdistutils.coreRtdistutils.dir_utilRtdistutils.versionRtdistutils.errorsRt	distutilsRtdistutils.utilRRvRRR	R
RRR
RR*(((s3/usr/lib64/python2.7/distutils/command/bdist_msi.pyt<module>s"=command/bdist_rpm.py000064400000051071151702014350010521 0ustar00"""distutils.command.bdist_rpm

Implements the Distutils 'bdist_rpm' command (create RPM source and binary
distributions)."""

__revision__ = "$Id$"

import sys
import os
import string

from distutils.core import Command
from distutils.debug import DEBUG
from distutils.file_util import write_file
from distutils.sysconfig import get_python_version
from distutils.errors import (DistutilsOptionError, DistutilsPlatformError,
                              DistutilsFileError, DistutilsExecError)
from distutils import log

class bdist_rpm (Command):

description = "create an RPM distribution"

user_options = [
        ('bdist-base=', None,
         "base directory for creating built distributions"),
        ('rpm-base=', None,
         "base directory for creating RPMs (defaults to \"rpm\" under "
         "--bdist-base; must be specified for RPM 2)"),
        ('dist-dir=', 'd',
         "directory to put final RPM files in "
         "(and .spec files if --spec-only)"),
        ('python=', None,
         "path to Python interpreter to hard-code in the .spec file "
         "(default: \"python\")"),
        ('fix-python', None,
         "hard-code the exact path to the current Python interpreter in "
         "the .spec file"),
        ('spec-only', None,
         "only regenerate spec file"),
        ('source-only', None,
         "only generate source RPM"),
        ('binary-only', None,
         "only generate binary RPM"),
        ('use-bzip2', None,
         "use bzip2 instead of gzip to create source distribution"),

# More meta-data: too RPM-specific to put in the setup script,
        # but needs to go in the .spec file -- so we make these options
        # to "bdist_rpm".  The idea is that packagers would put this
        # info in setup.cfg, although they are of course free to
        # supply it on the command line.
        ('distribution-name=', None,
         "name of the (Linux) distribution to which this "
         "RPM applies (*not* the name of the module distribution!)"),
        ('group=', None,
         "package classification [default: \"Development/Libraries\"]"),
        ('release=', None,
         "RPM release number"),
        ('serial=', None,
         "RPM serial number"),
        ('vendor=', None,
         "RPM \"vendor\" (eg. \"Joe Blow <joe@example.com>\") "
         "[default: maintainer or author from setup script]"),
        ('packager=', None,
         "RPM packager (eg. \"Jane Doe <jane@example.net>\") "
         "[default: vendor]"),
        ('doc-files=', None,
         "list of documentation files (space or comma-separated)"),
        ('changelog=', None,
         "RPM changelog"),
        ('icon=', None,
         "name of icon file"),
        ('provides=', None,
         "capabilities provided by this package"),
        ('requires=', None,
         "capabilities required by this package"),
        ('conflicts=', None,
         "capabilities which conflict with this package"),
        ('build-requires=', None,
         "capabilities required to build this package"),
        ('obsoletes=', None,
         "capabilities made obsolete by this package"),
        ('no-autoreq', None,
         "do not automatically calculate dependencies"),

# Actions to take when building RPM
        ('keep-temp', 'k',
         "don't clean up RPM build directory"),
        ('no-keep-temp', None,
         "clean up RPM build directory [default]"),
        ('use-rpm-opt-flags', None,
         "compile with RPM_OPT_FLAGS when building from source RPM"),
        ('no-rpm-opt-flags', None,
         "do not pass any RPM CFLAGS to compiler"),
        ('rpm3-mode', None,
         "RPM 3 compatibility mode (default)"),
        ('rpm2-mode', None,
         "RPM 2 compatibility mode"),

# Add the hooks necessary for specifying custom scripts
        ('prep-script=', None,
         "Specify a script for the PREP phase of RPM building"),
        ('build-script=', None,
         "Specify a script for the BUILD phase of RPM building"),

('pre-install=', None,
         "Specify a script for the pre-INSTALL phase of RPM building"),
        ('install-script=', None,
         "Specify a script for the INSTALL phase of RPM building"),
        ('post-install=', None,
         "Specify a script for the post-INSTALL phase of RPM building"),

('pre-uninstall=', None,
         "Specify a script for the pre-UNINSTALL phase of RPM building"),
        ('post-uninstall=', None,
         "Specify a script for the post-UNINSTALL phase of RPM building"),

('clean-script=', None,
         "Specify a script for the CLEAN phase of RPM building"),

('verify-script=', None,
         "Specify a script for the VERIFY phase of the RPM build"),

# Allow a packager to explicitly force an architecture
        ('force-arch=', None,
         "Force an architecture onto the RPM build process"),

('quiet', 'q',
         "Run the INSTALL phase of RPM building in quiet mode"),
        ]

boolean_options = ['keep-temp', 'use-rpm-opt-flags', 'rpm3-mode',
                       'no-autoreq', 'quiet']

negative_opt = {'no-keep-temp': 'keep-temp',
                    'no-rpm-opt-flags': 'use-rpm-opt-flags',
                    'rpm2-mode': 'rpm3-mode'}

def initialize_options (self):
        self.bdist_base = None
        self.rpm_base = None
        self.dist_dir = None
        self.python = None
        self.fix_python = None
        self.spec_only = None
        self.binary_only = None
        self.source_only = None
        self.use_bzip2 = None

self.distribution_name = None
        self.group = None
        self.release = None
        self.serial = None
        self.vendor = None
        self.packager = None
        self.doc_files = None
        self.changelog = None
        self.icon = None

self.prep_script = None
        self.build_script = None
        self.install_script = None
        self.clean_script = None
        self.verify_script = None
        self.pre_install = None
        self.post_install = None
        self.pre_uninstall = None
        self.post_uninstall = None
        self.prep = None
        self.provides = None
        self.requires = None
        self.conflicts = None
        self.build_requires = None
        self.obsoletes = None

self.keep_temp = 0
        self.use_rpm_opt_flags = 1
        self.rpm3_mode = 1
        self.no_autoreq = 0

self.force_arch = None
        self.quiet = 0

# initialize_options()

def finalize_options (self):
        self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
        if self.rpm_base is None:
            if not self.rpm3_mode:
                raise DistutilsOptionError, \
                      "you must specify --rpm-base in RPM 2 mode"
            self.rpm_base = os.path.join(self.bdist_base, "rpm")

if self.python is None:
            if self.fix_python:
                self.python = sys.executable
            else:
                self.python = "python"
        elif self.fix_python:
            raise DistutilsOptionError, \
                  "--python and --fix-python are mutually exclusive options"

if os.name != 'posix':
            raise DistutilsPlatformError, \
                  ("don't know how to create RPM "
                   "distributions on platform %s" % os.name)
        if self.binary_only and self.source_only:
            raise DistutilsOptionError, \
                  "cannot supply both '--source-only' and '--binary-only'"

# don't pass CFLAGS to pure python distributions
        if not self.distribution.has_ext_modules():
            self.use_rpm_opt_flags = 0

self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
        self.finalize_package_data()

# finalize_options()

def finalize_package_data (self):
        self.ensure_string('group', "Development/Libraries")
        self.ensure_string('vendor',
                           "%s <%s>" % (self.distribution.get_contact(),
                                        self.distribution.get_contact_email()))
        self.ensure_string('packager')
        self.ensure_string_list('doc_files')
        if isinstance(self.doc_files, list):
            for readme in ('README', 'README.txt'):
                if os.path.exists(readme) and readme not in self.doc_files:
                    self.doc_files.append(readme)

self.ensure_string('release', "1")
        self.ensure_string('serial')   # should it be an int?

self.ensure_string('distribution_name')

self.ensure_string('changelog')
          # Format changelog correctly
        self.changelog = self._format_changelog(self.changelog)

self.ensure_filename('icon')

self.ensure_filename('prep_script')
        self.ensure_filename('build_script')
        self.ensure_filename('install_script')
        self.ensure_filename('clean_script')
        self.ensure_filename('verify_script')
        self.ensure_filename('pre_install')
        self.ensure_filename('post_install')
        self.ensure_filename('pre_uninstall')
        self.ensure_filename('post_uninstall')

# XXX don't forget we punted on summaries and descriptions -- they
        # should be handled here eventually!

# Now *this* is some meta-data that belongs in the setup script...
        self.ensure_string_list('provides')
        self.ensure_string_list('requires')
        self.ensure_string_list('conflicts')
        self.ensure_string_list('build_requires')
        self.ensure_string_list('obsoletes')

self.ensure_string('force_arch')
    # finalize_package_data ()

def run (self):

if DEBUG:
            print "before _get_package_data():"
            print "vendor =", self.vendor
            print "packager =", self.packager
            print "doc_files =", self.doc_files
            print "changelog =", self.changelog

# make directories
        if self.spec_only:
            spec_dir = self.dist_dir
            self.mkpath(spec_dir)
        else:
            rpm_dir = {}
            for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
                rpm_dir[d] = os.path.join(self.rpm_base, d)
                self.mkpath(rpm_dir[d])
            spec_dir = rpm_dir['SPECS']

# Spec file goes into 'dist_dir' if '--spec-only specified',
        # build/rpm.<plat> otherwise.
        spec_path = os.path.join(spec_dir,
                                 "%s.spec" % self.distribution.get_name())
        self.execute(write_file,
                     (spec_path,
                      self._make_spec_file()),
                     "writing '%s'" % spec_path)

if self.spec_only: # stop if requested
            return

# Make a source distribution and copy to SOURCES directory with
        # optional icon.
        saved_dist_files = self.distribution.dist_files[:]
        sdist = self.reinitialize_command('sdist')
        if self.use_bzip2:
            sdist.formats = ['bztar']
        else:
            sdist.formats = ['gztar']
        self.run_command('sdist')
        self.distribution.dist_files = saved_dist_files

source = sdist.get_archive_files()[0]
        source_dir = rpm_dir['SOURCES']
        self.copy_file(source, source_dir)

if self.icon:
            if os.path.exists(self.icon):
                self.copy_file(self.icon, source_dir)
            else:
                raise DistutilsFileError, \
                      "icon file '%s' does not exist" % self.icon

# build package
        log.info("building RPMs")
        rpm_cmd = ['rpm']
        if os.path.exists('/usr/bin/rpmbuild') or \
           os.path.exists('/bin/rpmbuild'):
            rpm_cmd = ['rpmbuild']

if self.source_only: # what kind of RPMs?
            rpm_cmd.append('-bs')
        elif self.binary_only:
            rpm_cmd.append('-bb')
        else:
            rpm_cmd.append('-ba')
        if self.rpm3_mode:
            rpm_cmd.extend(['--define',
                             '_topdir %s' % os.path.abspath(self.rpm_base)])
        if not self.keep_temp:
            rpm_cmd.append('--clean')

if self.quiet:
            rpm_cmd.append('--quiet')

rpm_cmd.append(spec_path)
        # Determine the binary rpm names that should be built out of this spec
        # file
        # Note that some of these may not be really built (if the file
        # list is empty)
        nvr_string = "%{name}-%{version}-%{release}"
        src_rpm = nvr_string + ".src.rpm"
        non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
        q_cmd = r"rpm -q --qf '%s %s\n' --specfile '%s'" % (
            src_rpm, non_src_rpm, spec_path)

out = os.popen(q_cmd)
        try:
            binary_rpms = []
            source_rpm = None
            while 1:
                line = out.readline()
                if not line:
                    break
                l = string.split(string.strip(line))
                assert(len(l) == 2)
                binary_rpms.append(l[1])
                # The source rpm is named after the first entry in the spec file
                if source_rpm is None:
                    source_rpm = l[0]

status = out.close()
            if status:
                raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))

finally:
            out.close()

self.spawn(rpm_cmd)

if not self.dry_run:
            if self.distribution.has_ext_modules():
                pyversion = get_python_version()
            else:
                pyversion = 'any'

if not self.binary_only:
                srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
                assert(os.path.exists(srpm))
                self.move_file(srpm, self.dist_dir)
                filename = os.path.join(self.dist_dir, source_rpm)
                self.distribution.dist_files.append(
                    ('bdist_rpm', pyversion, filename))

if not self.source_only:
                for rpm in binary_rpms:
                    rpm = os.path.join(rpm_dir['RPMS'], rpm)
                    if os.path.exists(rpm):
                        self.move_file(rpm, self.dist_dir)
                        filename = os.path.join(self.dist_dir,
                                                os.path.basename(rpm))
                        self.distribution.dist_files.append(
                            ('bdist_rpm', pyversion, filename))
    # run()

def _dist_path(self, path):
        return os.path.join(self.dist_dir, os.path.basename(path))

def _make_spec_file(self):
        """Generate the text of an RPM spec file and return it as a
        list of strings (one per line).
        """
        # definitions and headers
        spec_file = [
            '%define name ' + self.distribution.get_name(),
            '%define version ' + self.distribution.get_version().replace('-','_'),
            '%define unmangled_version ' + self.distribution.get_version(),
            '%define release ' + self.release.replace('-','_'),
            '',
            'Summary: ' + self.distribution.get_description(),
            ]

# put locale summaries into spec file
        # XXX not supported for now (hard to put a dictionary
        # in a config file -- arg!)
        #for locale in self.summaries.keys():
        #    spec_file.append('Summary(%s): %s' % (locale,
        #                                          self.summaries[locale]))

spec_file.extend([
            'Name: %{name}',
            'Version: %{version}',
            'Release: %{release}',])

# XXX yuck! this filename is available from the "sdist" command,
        # but only after it has run: and we create the spec file before
        # running "sdist", in case of --spec-only.
        if self.use_bzip2:
            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2')
        else:
            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz')

spec_file.extend([
            'License: ' + self.distribution.get_license(),
            'Group: ' + self.group,
            'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot',
            'Prefix: %{_prefix}', ])

if not self.force_arch:
            # noarch if no extension modules
            if not self.distribution.has_ext_modules():
                spec_file.append('BuildArch: noarch')
        else:
            spec_file.append( 'BuildArch: %s' % self.force_arch )

for field in ('Vendor',
                      'Packager',
                      'Provides',
                      'Requires',
                      'Conflicts',
                      'Obsoletes',
                      ):
            val = getattr(self, string.lower(field))
            if isinstance(val, list):
                spec_file.append('%s: %s' % (field, string.join(val)))
            elif val is not None:
                spec_file.append('%s: %s' % (field, val))

if self.distribution.get_url() != 'UNKNOWN':
            spec_file.append('Url: ' + self.distribution.get_url())

if self.distribution_name:
            spec_file.append('Distribution: ' + self.distribution_name)

if self.build_requires:
            spec_file.append('BuildRequires: ' +
                             string.join(self.build_requires))

if self.icon:
            spec_file.append('Icon: ' + os.path.basename(self.icon))

if self.no_autoreq:
            spec_file.append('AutoReq: 0')

spec_file.extend([
            '',
            '%description',
            self.distribution.get_long_description()
            ])

# put locale descriptions into spec file
        # XXX again, suppressed because config file syntax doesn't
        # easily support this ;-(
        #for locale in self.descriptions.keys():
        #    spec_file.extend([
        #        '',
        #        '%description -l ' + locale,
        #        self.descriptions[locale],
        #        ])

# rpm scripts
        # figure out default build script
        def_setup_call = "%s %s" % (self.python,os.path.basename(sys.argv[0]))
        def_build = "%s build" % def_setup_call
        if self.use_rpm_opt_flags:
            def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build

# insert contents of files

# XXX this is kind of misleading: user-supplied options are files
        # that we open and interpolate into the spec file, but the defaults
        # are just text that we drop in as-is.  Hmmm.

install_cmd = ('%s install -O1 --root=$RPM_BUILD_ROOT '
                       '--record=INSTALLED_FILES') % def_setup_call

script_options = [
            ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"),
            ('build', 'build_script', def_build),
            ('install', 'install_script', install_cmd),
            ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"),
            ('verifyscript', 'verify_script', None),
            ('pre', 'pre_install', None),
            ('post', 'post_install', None),
            ('preun', 'pre_uninstall', None),
            ('postun', 'post_uninstall', None),
        ]

for (rpm_opt, attr, default) in script_options:
            # Insert contents of file referred to, if no file is referred to
            # use 'default' as contents of script
            val = getattr(self, attr)
            if val or default:
                spec_file.extend([
                    '',
                    '%' + rpm_opt,])
                if val:
                    spec_file.extend(string.split(open(val, 'r').read(), '\n'))
                else:
                    spec_file.append(default)

# files section
        spec_file.extend([
            '',
            '%files -f INSTALLED_FILES',
            '%defattr(-,root,root)',
            ])

if self.doc_files:
            spec_file.append('%doc ' + string.join(self.doc_files))

if self.changelog:
            spec_file.extend([
                '',
                '%changelog',])
            spec_file.extend(self.changelog)

return spec_file

# _make_spec_file ()

def _format_changelog(self, changelog):
        """Format the changelog correctly and convert it to a list of strings
        """
        if not changelog:
            return changelog
        new_changelog = []
        for line in string.split(string.strip(changelog), '\n'):
            line = string.strip(line)
            if line[0] == '*':
                new_changelog.extend(['', line])
            elif line[0] == '-':
                new_changelog.append(line)
            else:
                new_changelog.append('  ' + line)

# strip trailing newline inserted by first changelog entry
        if not new_changelog[0]:
            del new_changelog[0]

return new_changelog

# _format_changelog()

# class bdist_rpm
command/bdist_rpm.pyc000064400000042310151702014350010660 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZddlmZddl	m
Z
ddlmZddl
mZmZmZmZdd	lmZd
efd��YZdS(swdistutils.command.bdist_rpm

Implements the Distutils 'bdist_rpm' command (create RPM source and binary
distributions).s$Id$i����N(tCommand(tDEBUG(t
write_file(tget_python_version(tDistutilsOptionErrortDistutilsPlatformErrortDistutilsFileErrortDistutilsExecError(tlogt	bdist_rpmc+Bs�eZdZd^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwdxdydzd{d|d}d~dd�d�d�d�d�d�d�g)Zd2d7d;d0dSgZid2d56d7d96d;d=6ZdV�ZdW�ZdX�Z	dY�Z
dZ�Zd[�Zd\�Z
RS(�screate an RPM distributionsbdist-base=s/base directory for creating built distributionss	rpm-base=sdbase directory for creating RPMs (defaults to "rpm" under --bdist-base; must be specified for RPM 2)s	dist-dir=tdsDdirectory to put final RPM files in (and .spec files if --spec-only)spython=sMpath to Python interpreter to hard-code in the .spec file (default: "python")s
fix-pythonsLhard-code the exact path to the current Python interpreter in the .spec files	spec-onlysonly regenerate spec filessource-onlysonly generate source RPMsbinary-onlysonly generate binary RPMs	use-bzip2s7use bzip2 instead of gzip to create source distributionsdistribution-name=sgname of the (Linux) distribution to which this RPM applies (*not* the name of the module distribution!)sgroup=s9package classification [default: "Development/Libraries"]srelease=sRPM release numbersserial=sRPM serial numbersvendor=saRPM "vendor" (eg. "Joe Blow <joe@example.com>") [default: maintainer or author from setup script]s	packager=sBRPM packager (eg. "Jane Doe <jane@example.net>") [default: vendor]s
doc-files=s6list of documentation files (space or comma-separated)s
changelog=s
RPM changelogsicon=sname of icon files	provides=s%capabilities provided by this packages	requires=s%capabilities required by this packages
conflicts=s-capabilities which conflict with this packagesbuild-requires=s+capabilities required to build this packages
obsoletes=s*capabilities made obsolete by this packages
no-autoreqs+do not automatically calculate dependenciess	keep-temptks"don't clean up RPM build directorysno-keep-temps&clean up RPM build directory [default]suse-rpm-opt-flagss8compile with RPM_OPT_FLAGS when building from source RPMsno-rpm-opt-flagss&do not pass any RPM CFLAGS to compilers	rpm3-modes"RPM 3 compatibility mode (default)s	rpm2-modesRPM 2 compatibility modesprep-script=s3Specify a script for the PREP phase of RPM buildings
build-script=s4Specify a script for the BUILD phase of RPM buildingspre-install=s:Specify a script for the pre-INSTALL phase of RPM buildingsinstall-script=s6Specify a script for the INSTALL phase of RPM buildings
post-install=s;Specify a script for the post-INSTALL phase of RPM buildingspre-uninstall=s<Specify a script for the pre-UNINSTALL phase of RPM buildingspost-uninstall=s=Specify a script for the post-UNINSTALL phase of RPM buildings
clean-script=s4Specify a script for the CLEAN phase of RPM buildingsverify-script=s6Specify a script for the VERIFY phase of the RPM buildsforce-arch=s0Force an architecture onto the RPM build processtquiettqs3Run the INSTALL phase of RPM building in quiet modecCscd|_d|_d|_d|_d|_d|_d|_d|_d|_	d|_
d|_d|_d|_
d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_ d|_!d|_"d|_#d|_$d|_%d|_&d|_'dS(Nii((tNonet
bdist_basetrpm_basetdist_dirtpythont
fix_pythont	spec_onlytbinary_onlytsource_onlyt	use_bzip2tdistribution_nametgrouptreleasetserialtvendortpackagert	doc_filest	changelogticontprep_scripttbuild_scripttinstall_scripttclean_scriptt
verify_scripttpre_installtpost_installt
pre_uninstalltpost_uninstalltpreptprovidestrequirest	conflictstbuild_requirest	obsoletest	keep_temptuse_rpm_opt_flagst	rpm3_modet
no_autoreqt
force_archR(tself((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pytinitialize_options�sN																																						cCs|jdd�|jdkrR|js4td�ntjj|jd�|_n|j	dkr�|j
rytj|_	q�d|_	n|j
r�td�ntj
dkr�tdtj
�n|jr�|jr�td	�n|jj�s�d
|_n|jdd
�|j�dS(NtbdistRs)you must specify --rpm-base in RPM 2 modetrpmRs8--python and --fix-python are mutually exclusive optionstposixs9don't know how to create RPM distributions on platform %ss6cannot supply both '--source-only' and '--binary-only'iR(RR(RR(tset_undefined_optionsRRR2RtostpathtjoinRRRtsyst
executabletnameRRRtdistributionthas_ext_modulesR1tfinalize_package_data(R5((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pytfinalize_options�s0					
	cCs�|jdd�|jdd|jj�|jj�f�|jd�|jd�t|jt�r�xEdD]:}tj	j
|�ro||jkro|jj|�qoqoWn|jd	d
�|jd�|jd�|jd
�|j|j
�|_
|jd�|jd�|jd�|jd�|jd�|jd�|jd�|jd�|jd�|jd�|jd�|jd�|jd�|jd�|jd�|jd�dS(NRsDevelopment/LibrariesRs%s <%s>RRtREADMEs
README.txtRt1RRRR R!R"R#R$R%R&R'R(R)R+R,R-R.R/R4(REs
README.txt(t
ensure_stringRAtget_contacttget_contact_emailtensure_string_listt
isinstanceRtlistR;R<texiststappendt_format_changelogRtensure_filename(R5treadme((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pyRC�s>

cCs tr>dGHdG|jGHdG|jGHdG|jGHdG|jGHn|jr`|j}|j|�nNi}x;d(D]3}tj	j
|j|�||<|j||�qmW|d}tj	j
|d|jj
��}|jt||j�fd|�|jrdS|jj}|jd
�}|jr4dg|_ndg|_|jd
�||j_|j�d}|d}|j||�|jr�tj	j|j�r�|j|j|�q�td|j�ntjd�dg}	tj	jd�stj	jd�rdg}	n|jr)|	jd�n&|jrB|	jd�n
|	jd�|j r�|	j!ddtj	j"|j�g�n|j#s�|	jd�n|j$r�|	jd�n|	j|�d}
|
d}d |
d!}d"|||f}
tj%|
�}z�g}d}xt|j'�}|s(Pnt(j)t(j*|��}t+|�d#ksXt,�|j|d$�|dkr|d}qqW|j-�}|r�t.d%t/|
���nWd|j-�X|j0|	�|j1s|jj2�r�t3�}nd&}|js{tj	j
|d
|�}tj	j|�s1t,�|j4||j�tj	j
|j|�}|jjjd'||f�n|jsx�|D]�}tj	j
|d	|�}tj	j|�r�|j4||j�tj	j
|jtj	j5|��}|jjjd'||f�q�q�WqndS()Nsbefore _get_package_data():svendor =s
packager =sdoc_files =schangelog =tSOURCEStSPECStBUILDtRPMStSRPMSs%s.specswriting '%s'tsdisttbztartgztarisicon file '%s' does not exists
building RPMsR8s/usr/bin/rpmbuilds
/bin/rpmbuildtrpmbuilds-bss-bbs-bas--defines
_topdir %ss--cleans--quiets%{name}-%{version}-%{release}s.src.rpms%{arch}/s.%{arch}.rpms%rpm -q --qf '%s %s\n' --specfile '%s'iisFailed to execute: %stanyR	(RRRSRTRURV(6RRRRRRRtmkpathR;R<R=RRAtget_nametexecuteRt_make_spec_filet
dist_filestreinitialize_commandRtformatstrun_commandtget_archive_filest	copy_fileR RMRRtinfoRRNRR2textendtabspathR0RtpopenRtreadlinetstringtsplittstriptlentAssertionErrortcloseRtreprtspawntdry_runRBRt	move_filetbasename(R5tspec_dirtrpm_dirR
t	spec_pathtsaved_dist_filesRWtsourcet
source_dirtrpm_cmdt
nvr_stringtsrc_rpmtnon_src_rpmtq_cmdtouttbinary_rpmst
source_rpmtlinetltstatust	pyversiontsrpmtfilenameR8((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pytruns�

cCs"tjj|jtjj|��S(N(R;R<R=RRu(R5R<((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pyt
_dist_path�scCs�d|jj�d|jj�jdd�d|jj�d|jjdd�dd|jj�g}|jd	d
dg�|jr�|jd�n
|jd
�|jd|jj	�d|j
ddg�|js�|jj�s|jd�qn|jd|j�x~dBD]v}t
|tj|��}t|t�rj|jd|tj|�f�q|dCk	r|jd||f�qqW|jj�dkr�|jd|jj��n|jr�|jd|j�n|jr|jdtj|j��n|jr;|jdtjj|j��n|jrT|jd �n|jdd!|jj�g�d"|jtjjtjd#�f}d$|}|j r�d%|}nd&|}dDd*d+|fd,d-|fdEdFdGdHdIdJg	}x�|D]�\}}	}
t
||	�}|s'|
r�|jdd;|g�|ro|jtj!t"|d<�j#�d=��q|j|
�q�q�W|jdd>d?g�|j$r�|jd@tj|j$��n|j%r�|jddAg�|j|j%�n|S(KsiGenerate the text of an RPM spec file and return it as a
        list of strings (one per line).
        s
%define name s%define version t-t_s%define unmangled_version s%define release ts	Summary: s
Name: %{name}sVersion: %{version}sRelease: %{release}s-Source0: %{name}-%{unmangled_version}.tar.bz2s,Source0: %{name}-%{unmangled_version}.tar.gzs	License: sGroup: s>BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildrootsPrefix: %{_prefix}sBuildArch: noarchs
BuildArch: %stVendortPackagertProvidestRequirest	Conflictst	Obsoletess%s: %stUNKNOWNsUrl: sDistribution: sBuildRequires: sIcon: s
AutoReq: 0s%descriptions%s %sis%s buildsenv CFLAGS="$RPM_OPT_FLAGS" s>%s install -O1 --root=$RPM_BUILD_ROOT --record=INSTALLED_FILESR*R!s&%setup -n %{name}-%{unmangled_version}tbuildR"tinstallR#tcleanR$srm -rf $RPM_BUILD_ROOTtverifyscriptR%tpreR&tpostR'tpreunR(tpostunR)t%trs
s%files -f INSTALLED_FILESs%defattr(-,root,root)s%doc s
%changelog(R�R�R�R�R�R�N(R*R!s&%setup -n %{name}-%{unmangled_version}(R�R$srm -rf $RPM_BUILD_ROOT(R�R%N(R�R&N(R�R'N(R�R(N(R�R)N(&RAR]tget_versiontreplaceRtget_descriptionRgRRNtget_licenseRR4RBtgetattrRktlowerRKRLR=Rtget_urlRR.R R;R<RuR3tget_long_descriptionRR>targvR1RltopentreadRR(R5t	spec_filetfieldtvaltdef_setup_callt	def_buildtinstall_cmdtscript_optionstrpm_opttattrtdefault((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pyR_�s�

#				#	&
	
	+
	 	
cCs�|s
|Sg}x�tjtj|�d�D]l}tj|�}|ddkrg|jd|g�q,|ddkr�|j|�q,|jd|�q,W|ds�|d=n|S(sKFormat the changelog correctly and convert it to a list of strings
        s
it*R�R�s  (RkRlRmRgRN(R5Rt
new_changelogR�((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pyRO5s"

N(sbdist-base=Ns/base directory for creating built distributions(s	rpm-base=Nsdbase directory for creating RPMs (defaults to "rpm" under --bdist-base; must be specified for RPM 2)(s	dist-dir=R
sDdirectory to put final RPM files in (and .spec files if --spec-only)(spython=NsMpath to Python interpreter to hard-code in the .spec file (default: "python")(s
fix-pythonNsLhard-code the exact path to the current Python interpreter in the .spec file(s	spec-onlyNsonly regenerate spec file(ssource-onlyNsonly generate source RPM(sbinary-onlyNsonly generate binary RPM(s	use-bzip2Ns7use bzip2 instead of gzip to create source distribution(sdistribution-name=Nsgname of the (Linux) distribution to which this RPM applies (*not* the name of the module distribution!)(sgroup=Ns9package classification [default: "Development/Libraries"](srelease=NsRPM release number(sserial=NsRPM serial number(svendor=NsaRPM "vendor" (eg. "Joe Blow <joe@example.com>") [default: maintainer or author from setup script](s	packager=NsBRPM packager (eg. "Jane Doe <jane@example.net>") [default: vendor](s
doc-files=Ns6list of documentation files (space or comma-separated)(s
changelog=Ns
RPM changelog(sicon=Nsname of icon file(s	provides=Ns%capabilities provided by this package(s	requires=Ns%capabilities required by this package(s
conflicts=Ns-capabilities which conflict with this package(sbuild-requires=Ns+capabilities required to build this package(s
obsoletes=Ns*capabilities made obsolete by this package(s
no-autoreqNs+do not automatically calculate dependencies(s	keep-tempRs"don't clean up RPM build directory(sno-keep-tempNs&clean up RPM build directory [default](suse-rpm-opt-flagsNs8compile with RPM_OPT_FLAGS when building from source RPM(sno-rpm-opt-flagsNs&do not pass any RPM CFLAGS to compiler(s	rpm3-modeNs"RPM 3 compatibility mode (default)(s	rpm2-modeNsRPM 2 compatibility mode(sprep-script=Ns3Specify a script for the PREP phase of RPM building(s
build-script=Ns4Specify a script for the BUILD phase of RPM building(spre-install=Ns:Specify a script for the pre-INSTALL phase of RPM building(sinstall-script=Ns6Specify a script for the INSTALL phase of RPM building(s
post-install=Ns;Specify a script for the post-INSTALL phase of RPM building(spre-uninstall=Ns<Specify a script for the pre-UNINSTALL phase of RPM building(spost-uninstall=Ns=Specify a script for the post-UNINSTALL phase of RPM building(s
clean-script=Ns4Specify a script for the CLEAN phase of RPM building(sverify-script=Ns6Specify a script for the VERIFY phase of the RPM build(sforce-arch=Ns0Force an architecture onto the RPM build process(RR
s3Run the INSTALL phase of RPM building in quiet mode(t__name__t
__module__tdescriptionRtuser_optionstboolean_optionstnegative_optR6RDRCR�R�R_RO(((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pyR	s�

0	"	/	�		�(t__doc__t__revision__R>R;Rktdistutils.coreRtdistutils.debugRtdistutils.file_utilRtdistutils.sysconfigRtdistutils.errorsRRRRt	distutilsRR	(((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pyt<module>s"command/bdist_rpm.pyo000064400000042164151702014350010703 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZddlmZddl	m
Z
ddlmZddl
mZmZmZmZdd	lmZd
efd��YZdS(swdistutils.command.bdist_rpm

cCs�tr>dGHdG|jGHdG|jGHdG|jGHdG|jGHn|jr`|j}|j|�nNi}x;d'D]3}tj	j
|j|�||<|j||�qmW|d}tj	j
|d|jj
��}|jt||j�fd|�|jrdS|jj}|jd
�}|jr4dg|_ndg|_|jd
�||j_|j�d}|d}|j||�|jr�tj	j|j�r�|j|j|�q�td|j�ntjd�dg}	tj	jd�stj	jd�rdg}	n|jr)|	jd�n&|jrB|	jd�n
|	jd�|j r�|	j!ddtj	j"|j�g�n|j#s�|	jd�n|j$r�|	jd�n|	j|�d}
|
d}d |
d!}d"|||f}
tj%|
�}z�g}d}x\|j'�}|s(Pnt(j)t(j*|��}|j|d#�|dkr|d}qqW|j+�}|r�t,d$t-|
���nWd|j+�X|j.|	�|j/s�|jj0�r�t1�}nd%}|jsKtj	j
|d
|�}|j2||j�tj	j
|j|�}|jjjd&||f�n|js�x�|D]�}tj	j
|d	|�}tj	j|�r[|j2||j�tj	j
|jtj	j3|��}|jjjd&||f�q[q[Wq�ndS((Nsbefore _get_package_data():svendor =s
packager =sdoc_files =schangelog =tSOURCEStSPECStBUILDtRPMStSRPMSs%s.specswriting '%s'tsdisttbztartgztarisicon file '%s' does not exists
building RPMsR8s/usr/bin/rpmbuilds
/bin/rpmbuildtrpmbuilds-bss-bbs-bas--defines
_topdir %ss--cleans--quiets%{name}-%{version}-%{release}s.src.rpms%{arch}/s.%{arch}.rpms%rpm -q --qf '%s %s\n' --specfile '%s'isFailed to execute: %stanyR	(RRRSRTRURV(4RRRRRRRtmkpathR;R<R=RRAtget_nametexecuteRt_make_spec_filet
dist_filestreinitialize_commandRtformatstrun_commandtget_archive_filest	copy_fileR RMRRtinfoRRNRR2textendtabspathR0RtpopenRtreadlinetstringtsplittstriptcloseRtreprtspawntdry_runRBRt	move_filetbasename(R5tspec_dirtrpm_dirR
t	spec_pathtsaved_dist_filesRWtsourcet
source_dirtrpm_cmdt
nvr_stringtsrc_rpmtnon_src_rpmtq_cmdtouttbinary_rpmst
source_rpmtlinetltstatust	pyversiontsrpmtfilenameR8((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pytruns�

cCs"tjj|jtjj|��S(N(R;R<R=RRs(R5R<((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pyt
_dist_path�scCs�d|jj�d|jj�jdd�d|jj�d|jjdd�dd|jj�g}|jd	d
dg�|jr�|jd�n
|jd
�|jd|jj	�d|j
ddg�|js�|jj�s|jd�qn|jd|j�x~dBD]v}t
|tj|��}t|t�rj|jd|tj|�f�q|dCk	r|jd||f�qqW|jj�dkr�|jd|jj��n|jr�|jd|j�n|jr|jdtj|j��n|jr;|jdtjj|j��n|jrT|jd �n|jdd!|jj�g�d"|jtjjtjd#�f}d$|}|j r�d%|}nd&|}dDd*d+|fd,d-|fdEdFdGdHdIdJg	}x�|D]�\}}	}
t
||	�}|s'|
r�|jdd;|g�|ro|jtj!t"|d<�j#�d=��q|j|
�q�q�W|jdd>d?g�|j$r�|jd@tj|j$��n|j%r�|jddAg�|j|j%�n|S(KsiGenerate the text of an RPM spec file and return it as a
        list of strings (one per line).
        s
%define name s%define version t-t_s%define unmangled_version s%define release ts	Summary: s
Name: %{name}sVersion: %{version}sRelease: %{release}s-Source0: %{name}-%{unmangled_version}.tar.bz2s,Source0: %{name}-%{unmangled_version}.tar.gzs	License: sGroup: s>BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildrootsPrefix: %{_prefix}sBuildArch: noarchs
BuildArch: %stVendortPackagertProvidestRequirest	Conflictst	Obsoletess%s: %stUNKNOWNsUrl: sDistribution: sBuildRequires: sIcon: s
AutoReq: 0s%descriptions%s %sis%s buildsenv CFLAGS="$RPM_OPT_FLAGS" s>%s install -O1 --root=$RPM_BUILD_ROOT --record=INSTALLED_FILESR*R!s&%setup -n %{name}-%{unmangled_version}tbuildR"tinstallR#tcleanR$srm -rf $RPM_BUILD_ROOTtverifyscriptR%tpreR&tpostR'tpreunR(tpostunR)t%trs
s%files -f INSTALLED_FILESs%defattr(-,root,root)s%doc s
%changelog(R�R�R�R�R�R�N(R*R!s&%setup -n %{name}-%{unmangled_version}(R�R$srm -rf $RPM_BUILD_ROOT(R�R%N(R�R&N(R�R'N(R�R(N(R�R)N(&RAR]tget_versiontreplaceRtget_descriptionRgRRNtget_licenseRR4RBtgetattrRktlowerRKRLR=Rtget_urlRR.R R;R<RsR3tget_long_descriptionRR>targvR1RltopentreadRR(R5t	spec_filetfieldtvaltdef_setup_callt	def_buildtinstall_cmdtscript_optionstrpm_opttattrtdefault((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pyR_�s�

0	"	/	�		�(t__doc__t__revision__R>R;Rktdistutils.coreRtdistutils.debugRtdistutils.file_utilRtdistutils.sysconfigRtdistutils.errorsRRRRt	distutilsRR	(((s3/usr/lib64/python2.7/distutils/command/bdist_rpm.pyt<module>s"command/build_clib.py000064400000017703151702014350010632 0ustar00"""distutils.command.build_clib

Implements the Distutils 'build_clib' command, to build a C/C++ library
that is included in the module distribution and needed by an extension
module."""

__revision__ = "$Id$"

# XXX this module has *lots* of code ripped-off quite transparently from
# build_ext.py -- not surprisingly really, as the work required to build
# a static library from a collection of C source files is not really all
# that different from what's required to build a shared object file from
# a collection of C source files.  Nevertheless, I haven't done the
# necessary refactoring to account for the overlap in code between the
# two modules, mainly because a number of subtle details changed in the
# cut 'n paste.  Sigh.

import os
from distutils.core import Command
from distutils.errors import DistutilsSetupError
from distutils.sysconfig import customize_compiler
from distutils import log

def show_compilers():
    from distutils.ccompiler import show_compilers
    show_compilers()

class build_clib(Command):

description = "build C/C++ libraries used by Python extensions"

user_options = [
        ('build-clib=', 'b',
         "directory to build C/C++ libraries to"),
        ('build-temp=', 't',
         "directory to put temporary build by-products"),
        ('debug', 'g',
         "compile with debugging information"),
        ('force', 'f',
         "forcibly build everything (ignore file timestamps)"),
        ('compiler=', 'c',
         "specify the compiler type"),
        ]

boolean_options = ['debug', 'force']

help_options = [
        ('help-compiler', None,
         "list available compilers", show_compilers),
        ]

def initialize_options(self):
        self.build_clib = None
        self.build_temp = None

# List of libraries to build
        self.libraries = None

# Compilation options for all libraries
        self.include_dirs = None
        self.define = None
        self.undef = None
        self.debug = None
        self.force = 0
        self.compiler = None

def finalize_options(self):
        # This might be confusing: both build-clib and build-temp default
        # to build-temp as defined by the "build" command.  This is because
        # I think that C libraries are really just temporary build
        # by-products, at least from the point of view of building Python
        # extensions -- but I want to keep my options open.
        self.set_undefined_options('build',
                                   ('build_temp', 'build_clib'),
                                   ('build_temp', 'build_temp'),
                                   ('compiler', 'compiler'),
                                   ('debug', 'debug'),
                                   ('force', 'force'))

self.libraries = self.distribution.libraries
        if self.libraries:
            self.check_library_list(self.libraries)

if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        if isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

# XXX same as for build_ext -- what about 'self.define' and
        # 'self.undef' ?

def run(self):
        if not self.libraries:
            return

# Yech -- this is cut 'n pasted from build_ext.py!
        from distutils.ccompiler import new_compiler
        self.compiler = new_compiler(compiler=self.compiler,
                                     dry_run=self.dry_run,
                                     force=self.force)
        customize_compiler(self.compiler)

if self.include_dirs is not None:
            self.compiler.set_include_dirs(self.include_dirs)
        if self.define is not None:
            # 'define' option is a list of (name,value) tuples
            for (name,value) in self.define:
                self.compiler.define_macro(name, value)
        if self.undef is not None:
            for macro in self.undef:
                self.compiler.undefine_macro(macro)

self.build_libraries(self.libraries)

def check_library_list(self, libraries):
        """Ensure that the list of libraries is valid.

`library` is presumably provided as a command option 'libraries'.
        This method checks that it is a list of 2-tuples, where the tuples
        are (library_name, build_info_dict).

Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        """
        if not isinstance(libraries, list):
            raise DistutilsSetupError, \
                  "'libraries' option must be a list of tuples"

for lib in libraries:
            if not isinstance(lib, tuple) and len(lib) != 2:
                raise DistutilsSetupError, \
                      "each element of 'libraries' must a 2-tuple"

name, build_info = lib

if not isinstance(name, str):
                raise DistutilsSetupError, \
                      "first element of each tuple in 'libraries' " + \
                      "must be a string (the library name)"
            if '/' in name or (os.sep != '/' and os.sep in name):
                raise DistutilsSetupError, \
                      ("bad library name '%s': " +
                       "may not contain directory separators") % \
                      lib[0]

if not isinstance(build_info, dict):
                raise DistutilsSetupError, \
                      "second element of each tuple in 'libraries' " + \
                      "must be a dictionary (build info)"

def get_library_names(self):
        # Assume the library list is valid -- 'check_library_list()' is
        # called from 'finalize_options()', so it should be!
        if not self.libraries:
            return None

lib_names = []
        for (lib_name, build_info) in self.libraries:
            lib_names.append(lib_name)
        return lib_names

def get_source_files(self):
        self.check_library_list(self.libraries)
        filenames = []
        for (lib_name, build_info) in self.libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError, \
                      ("in 'libraries' option (library '%s'), "
                       "'sources' must be present and must be "
                       "a list of source filenames") % lib_name

filenames.extend(sources)
        return filenames

def build_libraries(self, libraries):
        for (lib_name, build_info) in libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError, \
                      ("in 'libraries' option (library '%s'), " +
                       "'sources' must be present and must be " +
                       "a list of source filenames") % lib_name
            sources = list(sources)

log.info("building '%s' library", lib_name)

# First, compile the source code to object files in the library
            # directory.  (This should probably change to putting object
            # files in a temporary build directory.)
            macros = build_info.get('macros')
            include_dirs = build_info.get('include_dirs')
            objects = self.compiler.compile(sources,
                                            output_dir=self.build_temp,
                                            macros=macros,
                                            include_dirs=include_dirs,
                                            debug=self.debug)

# Now "link" the object files together into a static library.
            # (On Unix at least, this isn't really linking -- it just
            # builds an archive.  Whatever.)
            self.compiler.create_static_lib(objects, lib_name,
                                            output_dir=self.build_clib,
                                            debug=self.debug)
errors.pyc000064400000014215151702014350006576 0ustar00�
{fc@s�dZdZdefd��YZdefd��YZdefd��YZdefd	��YZd
efd��YZdefd
��YZdefd��YZ	defd��YZ
defd��YZdefd��YZdefd��YZ
defd��YZdefd��YZdefd��YZdefd��YZd efd!��YZd"efd#��YZd$efd%��YZd&efd'��YZd(S()s�distutils.errors

Provides exceptions used by the Distutils modules.  Note that Distutils
modules may raise standard exceptions; in particular, SystemExit is
usually raised for errors that are obviously the end-user's fault
(eg. bad command-line arguments).

This module is safe to use in "from ... import *" mode; it only exports
symbols whose names start with "Distutils" and end with "Error".s$Id$tDistutilsErrorcBseZdZRS(sThe root of all Distutils evil.(t__name__t
__module__t__doc__(((s(/usr/lib64/python2.7/distutils/errors.pyR
stDistutilsModuleErrorcBseZdZRS(s�Unable to load an expected module, or to find an expected class
    within some module (in particular, command modules and classes).(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRstDistutilsClassErrorcBseZdZRS(s�Some command class (or possibly distribution class, if anyone
    feels a need to subclass Distribution) is found not to be holding
    up its end of the bargain, ie. implementing some part of the
    "command "interface.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRstDistutilsGetoptErrorcBseZdZRS(s7The option table provided to 'fancy_getopt()' is bogus.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRstDistutilsArgErrorcBseZdZRS(saRaised by fancy_getopt in response to getopt.error -- ie. an
    error in the command line usage.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRstDistutilsFileErrorcBseZdZRS(s�Any problems in the filesystem: expected file not found, etc.
    Typically this is for problems that we detect before IOError or
    OSError could be raised.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR!stDistutilsOptionErrorcBseZdZRS(s�Syntactic/semantic errors in command options, such as use of
    mutually conflicting options, or inconsistent options,
    badly-spelled values, etc.  No distinction is made between option
    values originating in the setup script, the command line, config
    files, or what-have-you -- but if we *know* something originated in
    the setup script, we'll raise DistutilsSetupError instead.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR	&stDistutilsSetupErrorcBseZdZRS(sqFor errors that can be definitely blamed on the setup script,
    such as invalid keyword arguments to 'setup()'.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR
.stDistutilsPlatformErrorcBseZdZRS(s�We don't know how to do something on the current platform (but
    we do know how to do it on some platform) -- eg. trying to compile
    C files on a platform not supported by a CCompiler subclass.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR2stDistutilsExecErrorcBseZdZRS(s`Any problems executing an external program (such as the C
    compiler, when compiling C files).(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR7stDistutilsInternalErrorcBseZdZRS(soInternal inconsistencies or impossibilities (obviously, this
    should never be seen if the code is working!).(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR
;stDistutilsTemplateErrorcBseZdZRS(s%Syntax error in a file list template.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR?stDistutilsByteCompileErrorcBseZdZRS(sByte compile error.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRBstCCompilerErrorcBseZdZRS(s#Some compile/link operation failed.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRFstPreprocessErrorcBseZdZRS(s.Failure to preprocess one or more C/C++ files.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRIstCompileErrorcBseZdZRS(s2Failure to compile one or more C/C++ source files.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRLstLibErrorcBseZdZRS(sKFailure to create a static library from one or more C/C++ object
    files.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyROst	LinkErrorcBseZdZRS(s]Failure to link one or more C/C++ object files into an executable
    or shared library file.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRSstUnknownFileErrorcBseZdZRS(s(Attempt to process an unknown file type.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRWsN(Rt__revision__t	ExceptionRRRRRRR	R
RRR
RRRRRRRR(((s(/usr/lib64/python2.7/distutils/errors.pyt<module>	s(extension.pyc000064400000016364151702014350007305 0ustar00�
{fc@s�dZdZddlZddlZddlZddlTyddlZWnek
rcdZnXddd��YZ	d�Z
dS(	smdistutils.extension

Provides the Extension class, used to describe C/C++ extension
modules in setup scripts.s$Id$i����N(t*t	ExtensioncBs>eZdZdddddddddddddd�
ZRS(s4Just a collection of attributes that describes an extension
    module and everything needed to build it (hopefully in a portable
    way, but there are hooks that let you be as unportable as you need).

Instance attributes:
      name : string
        the full name of the extension, including any packages -- ie.
        *not* a filename or pathname, but Python dotted name
      sources : [string]
        list of source filenames, relative to the distribution root
        (where the setup script lives), in Unix form (slash-separated)
        for portability.  Source files may be C, C++, SWIG (.i),
        platform-specific resource files, or whatever else is recognized
        by the "build_ext" command as source for a Python extension.
      include_dirs : [string]
        list of directories to search for C/C++ header files (in Unix
        form for portability)
      define_macros : [(name : string, value : string|None)]
        list of macros to define; each macro is defined using a 2-tuple,
        where 'value' is either the string to define it to or None to
        define it without a particular value (equivalent of "#define
        FOO" in source or -DFOO on Unix C compiler command line)
      undef_macros : [string]
        list of macros to undefine explicitly
      library_dirs : [string]
        list of directories to search for C/C++ libraries at link time
      libraries : [string]
        list of library names (not filenames or paths) to link against
      runtime_library_dirs : [string]
        list of directories to search for C/C++ libraries at run time
        (for shared extensions, this is when the extension is loaded)
      extra_objects : [string]
        list of extra files to link with (eg. object files not implied
        by 'sources', static library that must be explicitly specified,
        binary resource files, etc.)
      extra_compile_args : [string]
        any extra platform- and compiler-specific information to use
        when compiling the source files in 'sources'.  For platforms and
        compilers where "command line" makes sense, this is typically a
        list of command-line arguments, but for other platforms it could
        be anything.
      extra_link_args : [string]
        any extra platform- and compiler-specific information to use
        when linking object files together to create the extension (or
        to create a new static Python interpreter).  Similar
        interpretation as for 'extra_compile_args'.
      export_symbols : [string]
        list of symbols to be exported from a shared extension.  Not
        used on all platforms, and not generally necessary for Python
        extensions, which typically export exactly one symbol: "init" +
        extension_name.
      swig_opts : [string]
        any extra options to pass to SWIG if a source file has the .i
        extension.
      depends : [string]
        list of files that the extension depends on
      language : string
        extension language (i.e. "c", "c++", "objc"). Will be detected
        from the source extensions if not provided.
    cKs�t|�tkstd��t|�tkrRtt|�tgt|�ks^td��||_||_|pyg|_|p�g|_	|p�g|_
|p�g|_|p�g|_|p�g|_
|	p�g|_|
p�g|_|p�g|_|pg|_|
pg|_|pg|_||_t|�r�|j�}|j�tt|�}dtj|d�}tdk	r�tj|�q�tjj|d�ndS(Ns'name' must be a strings#'sources' must be a list of stringssUnknown Extension options: s, s
( ttypet
StringTypetAssertionErrortListTypetmaptlentnametsourcestinclude_dirst
define_macrostundef_macrostlibrary_dirst	librariestruntime_library_dirst
extra_objectstextra_compile_argstextra_link_argstexport_symbolst	swig_optstdependstlanguagetkeystsorttreprtstringtjointwarningstNonetwarntsyststderrtwrite(tselfRR	R
RRR
RRRRRRRRRtkwtLtmsg((s+/usr/lib64/python2.7/distutils/extension.pyt__init__Zs6%				
N(t__name__t
__module__t__doc__RR&(((s+/usr/lib64/python2.7/distutils/extension.pyRs<cCs�ddlm}m}m}ddlm}ddlm}||�}||ddddddd	dd
d�}zag}xT|j�}	|	dkr�Pn|j
|	�r�q~|	d|	dko�dknr�|jd
|	�q~q�n||	|�}	||	�}
|
d}t|g�}d}
x�|
dD]�}|
dk	rZ|
j
|�d}
q/ntjj|�d}|dd!}|d}|d(kr�|jj
|�q/|dkr�|jj
|�q/|dkr0tj|d�}|dkr|jj
|df�q�|jj
|d|!||df�q/|dkrO|jj
|�q/|dkrn|jj
|�q/|dkr�|jj
|�q/|dkr�|jj
|�q/|dkr�|jj
|�q/|dkr�|j}
q/|dkr�|j}
q/|d kr|j}
q/|d!krD|jj
|�|s�|j}
q�q/|d kr\|j}
q/|d!kr�|jj
|�|s�|j}
q�q/|d)kr�|jj
|�q/|jd'|�q/W|j
|�q~WWd|j�X|S(*Ni����(tparse_makefiletexpand_makefile_varst_variable_rx(tTextFile(tsplit_quotedtstrip_commentsitskip_blankst
join_linest	lstrip_wst	rstrip_wsiRs'%s' lines not handled yetis.cs.ccs.cpps.cxxs.c++s.ms.mms-Is-Dt=s-Us-Cs-ls-Ls-Rs-rpaths-Xlinkers
-Xcompilers-us.as.sos.sls.os.dylibsunrecognized argument '%s'(s.cs.ccs.cpps.cxxs.c++s.ms.mm(s.as.sos.sls.os.dylib(tdistutils.sysconfigR*R+R,tdistutils.text_fileR-tdistutils.utilR.treadlineRtmatchRRtappendtostpathtsplitextR	R
RtfindRRRRR
RRRtclose(tfilenameR*R+R,R-R.tvarstfilet
extensionstlinetwordstmoduletexttappend_next_wordtwordtsuffixtswitchtvaluetequals((s+/usr/lib64/python2.7/distutils/extension.pytread_setup_file�s�	$

((R)t__revision__R;RRttypesRtImportErrorRRRN(((s+/usr/lib64/python2.7/distutils/extension.pyt<module>s$

qextension.pyo000064400000016022151702014350007310 0ustar00�
{fc@s�dZdZddlZddlZddlZddlTyddlZWnek
rcdZnXddd��YZ	d�Z
dS(	smdistutils.extension

Instance attributes:
      name : string
        the full name of the extension, including any packages -- ie.
        *not* a filename or pathname, but Python dotted name
      sources : [string]
        list of source filenames, relative to the distribution root
        (where the setup script lives), in Unix form (slash-separated)
        for portability.  Source files may be C, C++, SWIG (.i),
        platform-specific resource files, or whatever else is recognized
        by the "build_ext" command as source for a Python extension.
      include_dirs : [string]
        list of directories to search for C/C++ header files (in Unix
        form for portability)
      define_macros : [(name : string, value : string|None)]
        list of macros to define; each macro is defined using a 2-tuple,
        where 'value' is either the string to define it to or None to
        define it without a particular value (equivalent of "#define
        FOO" in source or -DFOO on Unix C compiler command line)
      undef_macros : [string]
        list of macros to undefine explicitly
      library_dirs : [string]
        list of directories to search for C/C++ libraries at link time
      libraries : [string]
        list of library names (not filenames or paths) to link against
      runtime_library_dirs : [string]
        list of directories to search for C/C++ libraries at run time
        (for shared extensions, this is when the extension is loaded)
      extra_objects : [string]
        list of extra files to link with (eg. object files not implied
        by 'sources', static library that must be explicitly specified,
        binary resource files, etc.)
      extra_compile_args : [string]
        any extra platform- and compiler-specific information to use
        when compiling the source files in 'sources'.  For platforms and
        compilers where "command line" makes sense, this is typically a
        list of command-line arguments, but for other platforms it could
        be anything.
      extra_link_args : [string]
        any extra platform- and compiler-specific information to use
        when linking object files together to create the extension (or
        to create a new static Python interpreter).  Similar
        interpretation as for 'extra_compile_args'.
      export_symbols : [string]
        list of symbols to be exported from a shared extension.  Not
        used on all platforms, and not generally necessary for Python
        extensions, which typically export exactly one symbol: "init" +
        extension_name.
      swig_opts : [string]
        any extra options to pass to SWIG if a source file has the .i
        extension.
      depends : [string]
        list of files that the extension depends on
      language : string
        extension language (i.e. "c", "c++", "objc"). Will be detected
        from the source extensions if not provided.
    cKsM||_||_|pg|_|p*g|_|p9g|_|pHg|_|pWg|_|pfg|_|	pug|_|
p�g|_	|p�g|_
|p�g|_|
p�g|_|p�g|_
||_t|�rI|j�}|j�tt|�}dtj|d�}tdk	r2tj|�qItjj|d�ndS(NsUnknown Extension options: s, s
(tnametsourcestinclude_dirst
define_macrostundef_macrostlibrary_dirst	librariestruntime_library_dirst
extra_objectstextra_compile_argstextra_link_argstexport_symbolst	swig_optstdependstlanguagetlentkeystsorttmaptreprtstringtjointwarningstNonetwarntsyststderrtwrite(tselfRRRRRRRR	R
RRR
RRRtkwtLtmsg((s+/usr/lib64/python2.7/distutils/extension.pyt__init__Zs.			
N(t__name__t
__module__t__doc__RR"(((s+/usr/lib64/python2.7/distutils/extension.pyRs<cCs�ddlm}m}m}ddlm}ddlm}||�}||ddddddd	dd
d�}zag}xT|j�}	|	dkr�Pn|j
|	�r�q~|	d|	dko�dknr�|jd
|	�q~q�n||	|�}	||	�}
|
d}t|g�}d}
x�|
dD]�}|
dk	rZ|
j
|�d}
q/ntjj|�d}|dd!}|d}|d(kr�|jj
|�q/|dkr�|jj
|�q/|dkr0tj|d�}|dkr|jj
|df�q�|jj
|d|!||df�q/|dkrO|jj
|�q/|dkrn|jj
|�q/|dkr�|jj
|�q/|dkr�|jj
|�q/|dkr�|jj
|�q/|dkr�|j}
q/|dkr�|j}
q/|d kr|j}
q/|d!krD|jj
|�|s�|j}
q�q/|d kr\|j}
q/|d!kr�|jj
|�|s�|j}
q�q/|d)kr�|jj
|�q/|jd'|�q/W|j
|�q~WWd|j�X|S(*Ni����(tparse_makefiletexpand_makefile_varst_variable_rx(tTextFile(tsplit_quotedtstrip_commentsitskip_blankst
join_linest	lstrip_wst	rstrip_wsiRs'%s' lines not handled yetis.cs.ccs.cpps.cxxs.c++s.ms.mms-Is-Dt=s-Us-Cs-ls-Ls-Rs-rpaths-Xlinkers
-Xcompilers-us.as.sos.sls.os.dylibsunrecognized argument '%s'(s.cs.ccs.cpps.cxxs.c++s.ms.mm(s.as.sos.sls.os.dylib(tdistutils.sysconfigR&R'R(tdistutils.text_fileR)tdistutils.utilR*treadlineRtmatchRRtappendtostpathtsplitextRRRtfindRRRRRR	RR
tclose(tfilenameR&R'R(R)R*tvarstfilet
extensionstlinetwordstmoduletexttappend_next_wordtwordtsuffixtswitchtvaluetequals((s+/usr/lib64/python2.7/distutils/extension.pytread_setup_file�s�	$

((R%t__revision__R7RRttypesRtImportErrorRRRJ(((s+/usr/lib64/python2.7/distutils/extension.pyt<module>s$

qfancy_getopt.py000064400000043034151702014350007602 0ustar00"""distutils.fancy_getopt

__revision__ = "$Id$"

import sys
import string
import re
import getopt
from distutils.errors import DistutilsGetoptError, DistutilsArgError

# Much like command_re in distutils.core, this is close to but not quite
# the same as a Python NAME -- except, in the spirit of most GNU
# utilities, we use '-' in place of '_'.  (The spirit of LISP lives on!)
# The similarities to NAME are again not a coincidence...
longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)'
longopt_re = re.compile(r'^%s$' % longopt_pat)

# For recognizing "negative alias" options, eg. "quiet=!verbose"
neg_alias_re = re.compile("^(%s)=!(%s)$" % (longopt_pat, longopt_pat))

# This is used to translate long options to legitimate Python identifiers
# (for use as attributes of some object).
longopt_xlate = string.maketrans('-', '_')

class FancyGetopt:
    """Wrapper around the standard 'getopt()' module that provides some
    handy extra functionality:
      * short and long options are tied together
      * options have help strings, and help text can be assembled
        from them
      * options set attributes of a passed-in object
      * boolean options can have "negative aliases" -- eg. if
        --quiet is the "negative alias" of --verbose, then "--quiet"
        on the command line sets 'verbose' to false
    """

def __init__ (self, option_table=None):

# The option table is (currently) a list of tuples.  The
        # tuples may have 3 or four values:
        #   (long_option, short_option, help_string [, repeatable])
        # if an option takes an argument, its long_option should have '='
        # appended; short_option should just be a single character, no ':'
        # in any case.  If a long_option doesn't have a corresponding
        # short_option, short_option should be None.  All option tuples
        # must have long options.
        self.option_table = option_table

# 'option_index' maps long option names to entries in the option
        # table (ie. those 3-tuples).
        self.option_index = {}
        if self.option_table:
            self._build_index()

# 'alias' records (duh) alias options; {'foo': 'bar'} means
        # --foo is an alias for --bar
        self.alias = {}

# 'negative_alias' keeps track of options that are the boolean
        # opposite of some other option
        self.negative_alias = {}

# These keep track of the information in the option table.  We
        # don't actually populate these structures until we're ready to
        # parse the command-line, since the 'option_table' passed in here
        # isn't necessarily the final word.
        self.short_opts = []
        self.long_opts = []
        self.short2long = {}
        self.attr_name = {}
        self.takes_arg = {}

# And 'option_order' is filled up in 'getopt()'; it records the
        # original order of options (and their values) on the command-line,
        # but expands short options, converts aliases, etc.
        self.option_order = []

# __init__ ()

def _build_index (self):
        self.option_index.clear()
        for option in self.option_table:
            self.option_index[option[0]] = option

def set_option_table (self, option_table):
        self.option_table = option_table
        self._build_index()

def add_option (self, long_option, short_option=None, help_string=None):
        if long_option in self.option_index:
            raise DistutilsGetoptError, \
                  "option conflict: already an option '%s'" % long_option
        else:
            option = (long_option, short_option, help_string)
            self.option_table.append(option)
            self.option_index[long_option] = option

def has_option (self, long_option):
        """Return true if the option table for this parser has an
        option with long name 'long_option'."""
        return long_option in self.option_index

def get_attr_name (self, long_option):
        """Translate long option name 'long_option' to the form it
        has as an attribute of some object: ie., translate hyphens
        to underscores."""
        return string.translate(long_option, longopt_xlate)

def _check_alias_dict (self, aliases, what):
        assert isinstance(aliases, dict)
        for (alias, opt) in aliases.items():
            if alias not in self.option_index:
                raise DistutilsGetoptError, \
                      ("invalid %s '%s': "
                       "option '%s' not defined") % (what, alias, alias)
            if opt not in self.option_index:
                raise DistutilsGetoptError, \
                      ("invalid %s '%s': "
                       "aliased option '%s' not defined") % (what, alias, opt)

def set_aliases (self, alias):
        """Set the aliases for this option parser."""
        self._check_alias_dict(alias, "alias")
        self.alias = alias

def set_negative_aliases (self, negative_alias):
        """Set the negative aliases for this option parser.
        'negative_alias' should be a dictionary mapping option names to
        option names, both the key and value must already be defined
        in the option table."""
        self._check_alias_dict(negative_alias, "negative alias")
        self.negative_alias = negative_alias

def _grok_option_table (self):
        """Populate the various data structures that keep tabs on the
        option table.  Called by 'getopt()' before it can do anything
        worthwhile.
        """
        self.long_opts = []
        self.short_opts = []
        self.short2long.clear()
        self.repeat = {}

for option in self.option_table:
            if len(option) == 3:
                long, short, help = option
                repeat = 0
            elif len(option) == 4:
                long, short, help, repeat = option
            else:
                # the option table is part of the code, so simply
                # assert that it is correct
                raise ValueError, "invalid option tuple: %r" % (option,)

# Type- and value-check the option names
            if not isinstance(long, str) or len(long) < 2:
                raise DistutilsGetoptError, \
                      ("invalid long option '%s': "
                       "must be a string of length >= 2") % long

if (not ((short is None) or
                     (isinstance(short, str) and len(short) == 1))):
                raise DistutilsGetoptError, \
                      ("invalid short option '%s': "
                       "must a single character or None") % short

self.repeat[long] = repeat
            self.long_opts.append(long)

if long[-1] == '=':             # option takes an argument?
                if short: short = short + ':'
                long = long[0:-1]
                self.takes_arg[long] = 1
            else:

# Is option is a "negative alias" for some other option (eg.
                # "quiet" == "!verbose")?
                alias_to = self.negative_alias.get(long)
                if alias_to is not None:
                    if self.takes_arg[alias_to]:
                        raise DistutilsGetoptError, \
                              ("invalid negative alias '%s': "
                               "aliased option '%s' takes a value") % \
                               (long, alias_to)

self.long_opts[-1] = long # XXX redundant?!
                    self.takes_arg[long] = 0

else:
                    self.takes_arg[long] = 0

# If this is an alias option, make sure its "takes arg" flag is
            # the same as the option it's aliased to.
            alias_to = self.alias.get(long)
            if alias_to is not None:
                if self.takes_arg[long] != self.takes_arg[alias_to]:
                    raise DistutilsGetoptError, \
                          ("invalid alias '%s': inconsistent with "
                           "aliased option '%s' (one of them takes a value, "
                           "the other doesn't") % (long, alias_to)

# Now enforce some bondage on the long option name, so we can
            # later translate it to an attribute name on some object.  Have
            # to do this a bit late to make sure we've removed any trailing
            # '='.
            if not longopt_re.match(long):
                raise DistutilsGetoptError, \
                      ("invalid long option name '%s' " +
                       "(must be letters, numbers, hyphens only") % long

self.attr_name[long] = self.get_attr_name(long)
            if short:
                self.short_opts.append(short)
                self.short2long[short[0]] = long

# for option_table

# _grok_option_table()

def getopt (self, args=None, object=None):
        """Parse command-line options in args. Store as attributes on object.

If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
        'object' is None or not supplied, creates a new OptionDummy
        object, stores option values there, and returns a tuple (args,
        object).  If 'object' is supplied, it is modified in place and
        'getopt()' just returns 'args'; in both cases, the returned
        'args' is a modified copy of the passed-in 'args' list, which
        is left untouched.
        """
        if args is None:
            args = sys.argv[1:]
        if object is None:
            object = OptionDummy()
            created_object = 1
        else:
            created_object = 0

self._grok_option_table()

short_opts = string.join(self.short_opts)
        try:
            opts, args = getopt.getopt(args, short_opts, self.long_opts)
        except getopt.error, msg:
            raise DistutilsArgError, msg

for opt, val in opts:
            if len(opt) == 2 and opt[0] == '-': # it's a short option
                opt = self.short2long[opt[1]]
            else:
                assert len(opt) > 2 and opt[:2] == '--'
                opt = opt[2:]

alias = self.alias.get(opt)
            if alias:
                opt = alias

if not self.takes_arg[opt]:     # boolean option?
                assert val == '', "boolean option can't have value"
                alias = self.negative_alias.get(opt)
                if alias:
                    opt = alias
                    val = 0
                else:
                    val = 1

attr = self.attr_name[opt]
            # The only repeating option at the moment is 'verbose'.
            # It has a negative option -q quiet, which should set verbose = 0.
            if val and self.repeat.get(attr) is not None:
                val = getattr(object, attr, 0) + 1
            setattr(object, attr, val)
            self.option_order.append((opt, val))

# for opts
        if created_object:
            return args, object
        else:
            return args

# getopt()

def get_option_order (self):
        """Returns the list of (option, value) tuples processed by the
        previous run of 'getopt()'.  Raises RuntimeError if
        'getopt()' hasn't been called yet.
        """
        if self.option_order is None:
            raise RuntimeError, "'getopt()' hasn't been called yet"
        else:
            return self.option_order

def generate_help (self, header=None):
        """Generate help text (a list of strings, one per suggested line of
        output) from the option table for this FancyGetopt object.
        """
        # Blithely assume the option table is good: probably wouldn't call
        # 'generate_help()' unless you've already called 'getopt()'.

# First pass: determine maximum length of long option names
        max_opt = 0
        for option in self.option_table:
            long = option[0]
            short = option[1]
            l = len(long)
            if long[-1] == '=':
                l = l - 1
            if short is not None:
                l = l + 5                   # " (-x)" where short == 'x'
            if l > max_opt:
                max_opt = l

opt_width = max_opt + 2 + 2 + 2     # room for indent + dashes + gutter

# Typical help block looks like this:
        #   --foo       controls foonabulation
        # Help block for longest option looks like this:
        #   --flimflam  set the flim-flam level
        # and with wrapped text:
        #   --flimflam  set the flim-flam level (must be between
        #               0 and 100, except on Tuesdays)
        # Options with short names will have the short name shown (but
        # it doesn't contribute to max_opt):
        #   --foo (-f)  controls foonabulation
        # If adding the short option would make the left column too wide,
        # we push the explanation off to the next line
        #   --flimflam (-l)
        #               set the flim-flam level
        # Important parameters:
        #   - 2 spaces before option block start lines
        #   - 2 dashes for each long option name
        #   - min. 2 spaces between option and explanation (gutter)
        #   - 5 characters (incl. space) for short option name

# Now generate lines of help text.  (If 80 columns were good enough
        # for Jesus, then 78 columns are good enough for me!)
        line_width = 78
        text_width = line_width - opt_width
        big_indent = ' ' * opt_width
        if header:
            lines = [header]
        else:
            lines = ['Option summary:']

for option in self.option_table:
            long, short, help = option[:3]
            text = wrap_text(help, text_width)
            if long[-1] == '=':
                long = long[0:-1]

# Case 1: no short option at all (makes life easy)
            if short is None:
                if text:
                    lines.append("  --%-*s  %s" % (max_opt, long, text[0]))
                else:
                    lines.append("  --%-*s  " % (max_opt, long))

# Case 2: we have a short option, so we have to include it
            # just after the long option
            else:
                opt_names = "%s (-%s)" % (long, short)
                if text:
                    lines.append("  --%-*s  %s" %
                                 (max_opt, opt_names, text[0]))
                else:
                    lines.append("  --%-*s" % opt_names)

for l in text[1:]:
                lines.append(big_indent + l)

# for self.option_table

return lines

# generate_help ()

def print_help (self, header=None, file=None):
        if file is None:
            file = sys.stdout
        for line in self.generate_help(header):
            file.write(line + "\n")

# class FancyGetopt

def fancy_getopt (options, negative_opt, object, args):
    parser = FancyGetopt(options)
    parser.set_negative_aliases(negative_opt)
    return parser.getopt(args, object)

WS_TRANS = string.maketrans(string.whitespace, ' ' * len(string.whitespace))

def wrap_text (text, width):
    """wrap_text(text : string, width : int) -> [string]

Split 'text' into multiple lines of no more than 'width' characters
    each, and return the list of strings that results.
    """

if text is None:
        return []
    if len(text) <= width:
        return [text]

text = string.expandtabs(text)
    text = string.translate(text, WS_TRANS)
    chunks = re.split(r'( +|-+)', text)
    chunks = filter(None, chunks)      # ' - ' results in empty strings
    lines = []

while chunks:

cur_line = []                   # list of chunks (to-be-joined)
        cur_len = 0                     # length of current line

while chunks:
            l = len(chunks[0])
            if cur_len + l <= width:    # can squeeze (at least) this chunk in
                cur_line.append(chunks[0])
                del chunks[0]
                cur_len = cur_len + l
            else:                       # this line is full
                # drop last chunk if all space
                if cur_line and cur_line[-1][0] == ' ':
                    del cur_line[-1]
                break

if chunks:                      # any chunks left to process?

# if the current line is still empty, then we had a single
            # chunk that's too big too fit on a line -- so we break
            # down and break it up at the line width
            if cur_len == 0:
                cur_line.append(chunks[0][0:width])
                chunks[0] = chunks[0][width:]

# all-whitespace chunks at the end of a line can be discarded
            # (and we know from the re.split above that if a chunk has
            # *any* whitespace, it is *all* whitespace)
            if chunks[0][0] == ' ':
                del chunks[0]

# and store this line in the list-of-all-lines -- as a single
        # string, of course!
        lines.append(string.join(cur_line, ''))

# while chunks

return lines

def translate_longopt(opt):
    """Convert a long option name to a valid Python identifier by
    changing "-" to "_".
    """
    return string.translate(opt, longopt_xlate)

class OptionDummy:
    """Dummy class just used as a place to hold command-line option
    values as instance attributes."""

def __init__ (self, options=[]):
        """Create a new OptionDummy instance.  The attributes listed in
        'options' will be initialized to None."""
        for opt in options:
            setattr(self, opt, None)
fancy_getopt.pyc000064400000027266151702014350007756 0ustar00�
{fc@s�dZdZddlZddlZddlZddlZddlmZmZdZ	ej
de	�Zej
de	e	f�Zej
dd	�Zd
fd��YZd�Zej
ejd
eej��Zd�Zd�Zdfd��YZdS(s6distutils.fancy_getopt

Wrapper around the standard getopt module that provides the following
additional features:
  * short and long options are tied together
  * options have help strings, so fancy_getopt could potentially
    create a complete usage summary
  * options set attributes of a passed-in object
s$Id$i����N(tDistutilsGetoptErrortDistutilsArgErrors[a-zA-Z](?:[a-zA-Z0-9-]*)s^%s$s^(%s)=!(%s)$t-t_tFancyGetoptcBs�eZdZdd�Zd�Zd�Zddd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
ddd�Zd�Zdd
�Zddd�ZRS(s�Wrapper around the standard 'getopt()' module that provides some
    handy extra functionality:
      * short and long options are tied together
      * options have help strings, and help text can be assembled
        from them
      * options set attributes of a passed-in object
      * boolean options can have "negative aliases" -- eg. if
        --quiet is the "negative alias" of --verbose, then "--quiet"
        on the command line sets 'verbose' to false
    cCst||_i|_|jr(|j�ni|_i|_g|_g|_i|_i|_i|_	g|_
dS(N(toption_tabletoption_indext_build_indextaliastnegative_aliast
short_optst	long_optst
short2longt	attr_namet	takes_argtoption_order(tselfR((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt__init__-s
			
							cCs6|jj�x"|jD]}||j|d<qWdS(Ni(RtclearR(Rtoption((s./usr/lib64/python2.7/distutils/fancy_getopt.pyRYs
cCs||_|j�dS(N(RR(RR((s./usr/lib64/python2.7/distutils/fancy_getopt.pytset_option_table^s	cCsO||jkrtd|�n,|||f}|jj|�||j|<dS(Ns'option conflict: already an option '%s'(RRRtappend(Rtlong_optiontshort_optionthelp_stringR((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
add_optionbs
cCs
||jkS(scReturn true if the option table for this parser has an
        option with long name 'long_option'.(R(RR((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
has_optionlscCstj|t�S(s�Translate long option name 'long_option' to the form it
        has as an attribute of some object: ie., translate hyphens
        to underscores.(tstringt	translatet
longopt_xlate(RR((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
get_attr_nameqscCs�t|t�st�xj|j�D]\\}}||jkrVtd|||f�n||jkr"td|||f�q"q"WdS(Ns(invalid %s '%s': option '%s' not defineds0invalid %s '%s': aliased option '%s' not defined(t
isinstancetdicttAssertionErrortitemsRR(RtaliasestwhatRtopt((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt_check_alias_dictxscCs|j|d�||_dS(s'Set the aliases for this option parser.RN(R&R(RR((s./usr/lib64/python2.7/distutils/fancy_getopt.pytset_aliases�scCs|j|d�||_dS(s�Set the negative aliases for this option parser.
        'negative_alias' should be a dictionary mapping option names to
        option names, both the key and value must already be defined
        in the option table.snegative aliasN(R&R	(RR	((s./usr/lib64/python2.7/distutils/fancy_getopt.pytset_negative_aliases�scCs�g|_g|_|jj�i|_x]|jD]R}t|�dkrb|\}}}d}n7t|�dkr�|\}}}}ntd|f�t|t	�s�t|�dkr�t
d|�n|dkp�t|t	�o�t|�dkst
d|�n||j|<|jj|�|d	d
kre|rH|d}n|dd	!}d|j
|<nk|jj|�}|dk	r�|j
|r�t
d||f�n||jd	<d|j
|<n
d|j
|<|jj|�}|dk	r!|j
||j
|kr!t
d
||f�q!ntj|�sDt
dd|�n|j|�|j|<|r2|jj|�||j|d<q2q2WdS(s�Populate the various data structures that keep tabs on the
        option table.  Called by 'getopt()' before it can do anything
        worthwhile.
        iiisinvalid option tuple: %ris9invalid long option '%s': must be a string of length >= 2is:invalid short option '%s': must a single character or Nonei����t=t:s>invalid negative alias '%s': aliased option '%s' takes a valuesginvalid alias '%s': inconsistent with aliased option '%s' (one of them takes a value, the other doesn'tsinvalid long option name '%s' s'(must be letters, numbers, hyphens onlyN(RR
RRtrepeatRtlent
ValueErrorRtstrRtNoneRRR	tgetRt
longopt_retmatchRR
(RRtlongtshortthelpR+talias_to((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt_grok_option_table�sd		
		"
!

cCs|dkrtjd}n|dkr:t�}d}nd}|j�tj|j�}y"tj|||j	�\}}Wntj
k
r�}t|�nXx\|D]T\}}t|�dkr�|ddkr�|j
|d}n2t|�dkr|d dkst�|d}|jj|�}	|	r<|	}n|j|s�|dksatd��|jj|�}	|	r�|	}d}q�d}n|j|}
|r�|jj|
�dk	r�t||
d�d}nt||
|�|jj||f�q�W|r||fS|SdS(	sParse command-line options in args. Store as attributes on object.

If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
        'object' is None or not supplied, creates a new OptionDummy
        object, stores option values there, and returns a tuple (args,
        object).  If 'object' is supplied, it is modified in place and
        'getopt()' just returns 'args'; in both cases, the returned
        'args' is a modified copy of the passed-in 'args' list, which
        is left untouched.
        iiiRs--tsboolean option can't have valueN(R/tsystargvtOptionDummyR7RtjoinR
tgetoptRterrorRR,RR!RR0RR	R
R+tgetattrtsetattrRR(Rtargstobjecttcreated_objectR
toptstmsgR%tvalRtattr((s./usr/lib64/python2.7/distutils/fancy_getopt.pyR=�sF		
"
"(

cCs&|jdkrtd�n|jSdS(s�Returns the list of (option, value) tuples processed by the
        previous run of 'getopt()'.  Raises RuntimeError if
        'getopt()' hasn't been called yet.
        s!'getopt()' hasn't been called yetN(RR/tRuntimeError(R((s./usr/lib64/python2.7/distutils/fancy_getopt.pytget_option_order*scCs�d}x||jD]q}|d}|d}t|�}|ddkrS|d}n|dk	rl|d}n||kr|}qqW|ddd}d}||}	d|}
|r�|g}n	d	g}x|jD]}|d
 \}}}t||	�}
|ddkr|dd!}n|dkrk|
rQ|jd|||
df�q�|jd||f�nHd
||f}|
r�|jd|||
df�n|jd|�x#|
dD]}|j|
|�q�Wq�W|S(s�Generate help text (a list of strings, one per suggested line of
        output) from the option table for this FancyGetopt object.
        iii����R)iiiNt sOption summary:is  --%-*s  %ss
  --%-*s  s%s (-%s)s  --%-*sN(RR,R/t	wrap_textR(Rtheadertmax_optRR3R4tlt	opt_widtht
line_widtht
text_widtht
big_indenttlinesR5ttextt	opt_names((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
generate_help5sF

!	cCsG|dkrtj}nx(|j|�D]}|j|d�q(WdS(Ns
(R/R9tstdoutRVtwrite(RRLtfiletline((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
print_help�sN(t__name__t
__module__t__doc__R/RRRRRRR&R'R(R7R=RIRVR[(((s./usr/lib64/python2.7/distutils/fancy_getopt.pyR!s
,		
							X@	TcCs)t|�}|j|�|j||�S(N(RR(R=(toptionstnegative_optRBRAtparser((s./usr/lib64/python2.7/distutils/fancy_getopt.pytfancy_getopt�s
RJcCs~|dkrgSt|�|kr)|gStj|�}tj|t�}tjd|�}td|�}g}x|ryg}d}xt|r�t|d�}|||kr�|j	|d�|d=||}q�|r�|dddkr�|d=nPq�W|r]|dkr<|j	|dd|!�|d||d<n|dddkr]|d=q]n|j	tj
|d��qtW|S(s�wrap_text(text : string, width : int) -> [string]

Split 'text' into multiple lines of no more than 'width' characters
    each, and return the list of strings that results.
    s( +|-+)ii����RJR8N(R/R,Rt
expandtabsRtWS_TRANStretsplittfilterRR<(RTtwidthtchunksRStcur_linetcur_lenRN((s./usr/lib64/python2.7/distutils/fancy_getopt.pyRK�s:

cCstj|t�S(sXConvert a long option name to a valid Python identifier by
    changing "-" to "_".
    (RRR(R%((s./usr/lib64/python2.7/distutils/fancy_getopt.pyttranslate_longopt�sR;cBseZdZgd�ZRS(s_Dummy class just used as a place to hold command-line option
    values as instance attributes.cCs%x|D]}t||d�qWdS(skCreate a new OptionDummy instance.  The attributes listed in
        'options' will be initialized to None.N(R@R/(RR_R%((s./usr/lib64/python2.7/distutils/fancy_getopt.pyR�s
(R\R]R^R(((s./usr/lib64/python2.7/distutils/fancy_getopt.pyR;�s(R^t__revision__R9RReR=tdistutils.errorsRRtlongopt_pattcompileR1tneg_alias_ret	maketransRRRbt
whitespaceR,RdRKRlR;(((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt<module>	s"�r	"	;	fancy_getopt.pyo000064400000027005151702014350007761 0ustar00�
{fc@s�dZdZddlZddlZddlZddlZddlmZmZdZ	ej
de	�Zej
de	e	f�Zej
dd	�Zd
fd��YZd�Zej
ejd
eej��Zd�Zd�Zdfd��YZdS(s6distutils.fancy_getopt

Wrapper around the standard getopt module that provides the following
additional features:
  * short and long options are tied together
  * options have help strings, so fancy_getopt could potentially
    create a complete usage summary
  * options set attributes of a passed-in object
s$Id$i����N(tDistutilsGetoptErrortDistutilsArgErrors[a-zA-Z](?:[a-zA-Z0-9-]*)s^%s$s^(%s)=!(%s)$t-t_tFancyGetoptcBs�eZdZdd�Zd�Zd�Zddd�Zd�Zd�Z	d�Z
d�Zd	�Zd
�Z
ddd�Zd�Zdd
�Zddd�ZRS(s�Wrapper around the standard 'getopt()' module that provides some
    handy extra functionality:
      * short and long options are tied together
      * options have help strings, and help text can be assembled
        from them
      * options set attributes of a passed-in object
      * boolean options can have "negative aliases" -- eg. if
        --quiet is the "negative alias" of --verbose, then "--quiet"
        on the command line sets 'verbose' to false
    cCst||_i|_|jr(|j�ni|_i|_g|_g|_i|_i|_i|_	g|_
dS(N(toption_tabletoption_indext_build_indextaliastnegative_aliast
short_optst	long_optst
short2longt	attr_namet	takes_argtoption_order(tselfR((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt__init__-s
			
							cCs6|jj�x"|jD]}||j|d<qWdS(Ni(RtclearR(Rtoption((s./usr/lib64/python2.7/distutils/fancy_getopt.pyRYs
cCs||_|j�dS(N(RR(RR((s./usr/lib64/python2.7/distutils/fancy_getopt.pytset_option_table^s	cCsO||jkrtd|�n,|||f}|jj|�||j|<dS(Ns'option conflict: already an option '%s'(RRRtappend(Rtlong_optiontshort_optionthelp_stringR((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
add_optionbs
cCs
||jkS(scReturn true if the option table for this parser has an
        option with long name 'long_option'.(R(RR((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
has_optionlscCstj|t�S(s�Translate long option name 'long_option' to the form it
        has as an attribute of some object: ie., translate hyphens
        to underscores.(tstringt	translatet
longopt_xlate(RR((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
get_attr_nameqscCsqxj|j�D]\\}}||jkrAtd|||f�n||jkr
td|||f�q
q
WdS(Ns(invalid %s '%s': option '%s' not defineds0invalid %s '%s': aliased option '%s' not defined(titemsRR(RtaliasestwhatRtopt((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt_check_alias_dictxscCs|j|d�||_dS(s'Set the aliases for this option parser.RN(R#R(RR((s./usr/lib64/python2.7/distutils/fancy_getopt.pytset_aliases�scCs|j|d�||_dS(s�Set the negative aliases for this option parser.
        'negative_alias' should be a dictionary mapping option names to
        option names, both the key and value must already be defined
        in the option table.snegative aliasN(R#R	(RR	((s./usr/lib64/python2.7/distutils/fancy_getopt.pytset_negative_aliases�scCs�g|_g|_|jj�i|_x]|jD]R}t|�dkrb|\}}}d}n7t|�dkr�|\}}}}ntd|f�t|t	�s�t|�dkr�t
d|�n|dkp�t|t	�o�t|�dkst
d|�n||j|<|jj|�|d	d
kre|rH|d}n|dd	!}d|j
|<nk|jj|�}|dk	r�|j
|r�t
d||f�n||jd	<d|j
|<n
d|j
|<|jj|�}|dk	r!|j
||j
|kr!t
d
||f�q!ntj|�sDt
dd|�n|j|�|j|<|r2|jj|�||j|d<q2q2WdS(s�Populate the various data structures that keep tabs on the
        option table.  Called by 'getopt()' before it can do anything
        worthwhile.
        iiisinvalid option tuple: %ris9invalid long option '%s': must be a string of length >= 2is:invalid short option '%s': must a single character or Nonei����t=t:s>invalid negative alias '%s': aliased option '%s' takes a valuesginvalid alias '%s': inconsistent with aliased option '%s' (one of them takes a value, the other doesn'tsinvalid long option name '%s' s'(must be letters, numbers, hyphens onlyN(RR
RRtrepeatRtlent
ValueErrort
isinstancetstrRtNoneRRR	tgetRt
longopt_retmatchRR
(RRtlongtshortthelpR(talias_to((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt_grok_option_table�sd		
		"
!

cCs�|dkrtjd}n|dkr:t�}d}nd}|j�tj|j�}y"tj|||j	�\}}Wntj
k
r�}t|�nXx|D]\}}t|�dkr�|ddkr�|j
|d}n
|d}|jj|�}	|	r|	}n|j|sQ|jj|�}	|	rH|	}d}qQd}n|j|}
|r�|jj|
�dk	r�t||
d�d}nt||
|�|jj||f�q�W|r�||fS|SdS(sParse command-line options in args. Store as attributes on object.

If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
        'object' is None or not supplied, creates a new OptionDummy
        object, stores option values there, and returns a tuple (args,
        object).  If 'object' is supplied, it is modified in place and
        'getopt()' just returns 'args'; in both cases, the returned
        'args' is a modified copy of the passed-in 'args' list, which
        is left untouched.
        iiiRN(R-tsystargvtOptionDummyR5RtjoinR
tgetoptRterrorRR)RRR.RR	R
R(tgetattrtsetattrRR(Rtargstobjecttcreated_objectR
toptstmsgR"tvalRtattr((s./usr/lib64/python2.7/distutils/fancy_getopt.pyR:�sB		
"
"

cCs&|jdkrtd�n|jSdS(s�Returns the list of (option, value) tuples processed by the
        previous run of 'getopt()'.  Raises RuntimeError if
        'getopt()' hasn't been called yet.
        s!'getopt()' hasn't been called yetN(RR-tRuntimeError(R((s./usr/lib64/python2.7/distutils/fancy_getopt.pytget_option_order*scCs�d}x||jD]q}|d}|d}t|�}|ddkrS|d}n|dk	rl|d}n||kr|}qqW|ddd}d}||}	d|}
|r�|g}n	d	g}x|jD]}|d
 \}}}t||	�}
|ddkr|dd!}n|dkrk|
rQ|jd|||
df�q�|jd||f�nHd
||f}|
r�|jd|||
df�n|jd|�x#|
dD]}|j|
|�q�Wq�W|S(s�Generate help text (a list of strings, one per suggested line of
        output) from the option table for this FancyGetopt object.
        iii����R&iiiNt sOption summary:is  --%-*s  %ss
  --%-*s  s%s (-%s)s  --%-*sN(RR)R-t	wrap_textR(Rtheadertmax_optRR1R2tlt	opt_widtht
line_widtht
text_widtht
big_indenttlinesR3ttextt	opt_names((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
generate_help5sF

!	cCsG|dkrtj}nx(|j|�D]}|j|d�q(WdS(Ns
(R-R6tstdoutRStwrite(RRItfiletline((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt
print_help�sN(t__name__t
__module__t__doc__R-RRRRRRR#R$R%R5R:RFRSRX(((s./usr/lib64/python2.7/distutils/fancy_getopt.pyR!s
,		
							X@	TcCs)t|�}|j|�|j||�S(N(RR%R:(toptionstnegative_optR?R>tparser((s./usr/lib64/python2.7/distutils/fancy_getopt.pytfancy_getopt�s
RGcCs~|dkrgSt|�|kr)|gStj|�}tj|t�}tjd|�}td|�}g}x|ryg}d}xt|r�t|d�}|||kr�|j	|d�|d=||}q�|r�|dddkr�|d=nPq�W|r]|dkr<|j	|dd|!�|d||d<n|dddkr]|d=q]n|j	tj
|d��qtW|S(s�wrap_text(text : string, width : int) -> [string]

Split 'text' into multiple lines of no more than 'width' characters
    each, and return the list of strings that results.
    s( +|-+)ii����RGtN(R-R)Rt
expandtabsRtWS_TRANStretsplittfilterRR9(RQtwidthtchunksRPtcur_linetcur_lenRK((s./usr/lib64/python2.7/distutils/fancy_getopt.pyRH�s:

cCstj|t�S(sXConvert a long option name to a valid Python identifier by
    changing "-" to "_".
    (RRR(R"((s./usr/lib64/python2.7/distutils/fancy_getopt.pyttranslate_longopt�sR8cBseZdZgd�ZRS(s_Dummy class just used as a place to hold command-line option
    values as instance attributes.cCs%x|D]}t||d�qWdS(skCreate a new OptionDummy instance.  The attributes listed in
        'options' will be initialized to None.N(R=R-(RR\R"((s./usr/lib64/python2.7/distutils/fancy_getopt.pyR�s
(RYRZR[R(((s./usr/lib64/python2.7/distutils/fancy_getopt.pyR8�s(R[t__revision__R6RRcR:tdistutils.errorsRRtlongopt_pattcompileR/tneg_alias_ret	maketransRRR_t
whitespaceR)RbRHRjR8(((s./usr/lib64/python2.7/distutils/fancy_getopt.pyt<module>	s"�r	"	;	file_util.py000064400000017703151702014350007100 0ustar00"""distutils.file_util

Utility functions for operating on single files.
"""

__revision__ = "$Id$"

import os
from distutils.errors import DistutilsFileError
from distutils import log

# for generating verbose output in 'copy_file()'
_copy_action = {None: 'copying',
                'hard': 'hard linking',
                'sym': 'symbolically linking'}

def _copy_file_contents(src, dst, buffer_size=16*1024):
    """Copy the file 'src' to 'dst'.

Both must be filenames. Any error opening either file, reading from
    'src', or writing to 'dst', raises DistutilsFileError.  Data is
    read/written in chunks of 'buffer_size' bytes (default 16k).  No attempt
    is made to handle anything apart from regular files.
    """
    # Stolen from shutil module in the standard library, but with
    # custom error-handling added.
    fsrc = None
    fdst = None
    try:
        try:
            fsrc = open(src, 'rb')
        except os.error, (errno, errstr):
            raise DistutilsFileError("could not open '%s': %s" % (src, errstr))

if os.path.exists(dst):
            try:
                os.unlink(dst)
            except os.error, (errno, errstr):
                raise DistutilsFileError(
                      "could not delete '%s': %s" % (dst, errstr))

try:
            fdst = open(dst, 'wb')
        except os.error, (errno, errstr):
            raise DistutilsFileError(
                  "could not create '%s': %s" % (dst, errstr))

while 1:
            try:
                buf = fsrc.read(buffer_size)
            except os.error, (errno, errstr):
                raise DistutilsFileError(
                      "could not read from '%s': %s" % (src, errstr))

if not buf:
                break

try:
                fdst.write(buf)
            except os.error, (errno, errstr):
                raise DistutilsFileError(
                      "could not write to '%s': %s" % (dst, errstr))

finally:
        if fdst:
            fdst.close()
        if fsrc:
            fsrc.close()

def copy_file(src, dst, preserve_mode=1, preserve_times=1, update=0,
              link=None, verbose=1, dry_run=0):
    """Copy a file 'src' to 'dst'.

If 'dst' is a directory, then 'src' is copied there with the same name;
    otherwise, it must be a filename.  (If the file exists, it will be
    ruthlessly clobbered.)  If 'preserve_mode' is true (the default),
    the file's mode (type and permission bits, or whatever is analogous on
    the current platform) is copied.  If 'preserve_times' is true (the
    default), the last-modified and last-access times are copied as well.
    If 'update' is true, 'src' will only be copied if 'dst' does not exist,
    or if 'dst' does exist but is older than 'src'.

'link' allows you to make hard links (os.link) or symbolic links
    (os.symlink) instead of copying: set it to "hard" or "sym"; if it is
    None (the default), files are copied.  Don't set 'link' on systems that
    don't support it: 'copy_file()' doesn't check if hard or symbolic
    linking is available. If hardlink fails, falls back to
    _copy_file_contents().

Under Mac OS, uses the native file copy function in macostools; on
    other systems, uses '_copy_file_contents()' to copy file contents.

Return a tuple (dest_name, copied): 'dest_name' is the actual name of
    the output file, and 'copied' is true if the file was copied (or would
    have been copied, if 'dry_run' true).
    """
    # XXX if the destination file already exists, we clobber it if
    # copying, but blow up if linking.  Hmmm.  And I don't know what
    # macostools.copyfile() does.  Should definitely be consistent, and
    # should probably blow up if destination exists and we would be
    # changing it (ie. it's not already a hard/soft link to src OR
    # (not update) and (src newer than dst).

from distutils.dep_util import newer
    from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE

if not os.path.isfile(src):
        raise DistutilsFileError(
              "can't copy '%s': doesn't exist or not a regular file" % src)

if os.path.isdir(dst):
        dir = dst
        dst = os.path.join(dst, os.path.basename(src))
    else:
        dir = os.path.dirname(dst)

if update and not newer(src, dst):
        if verbose >= 1:
            log.debug("not copying %s (output up-to-date)", src)
        return dst, 0

try:
        action = _copy_action[link]
    except KeyError:
        raise ValueError("invalid value '%s' for 'link' argument" % link)

if verbose >= 1:
        if os.path.basename(dst) == os.path.basename(src):
            log.info("%s %s -> %s", action, src, dir)
        else:
            log.info("%s %s -> %s", action, src, dst)

if dry_run:
        return (dst, 1)

# If linking (hard or symbolic), use the appropriate system call
    # (Unix only, of course, but that's the caller's responsibility)
    if link == 'hard':
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            try:
                os.link(src, dst)
                return (dst, 1)
            except OSError:
                # If hard linking fails, fall back on copying file
                # (some special filesystems don't support hard linking
                #  even under Unix, see issue #8876).
                pass
    elif link == 'sym':
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            os.symlink(src, dst)
            return (dst, 1)

# Otherwise (non-Mac, not linking), copy the file contents and
    # (optionally) copy the times and mode.
    _copy_file_contents(src, dst)
    if preserve_mode or preserve_times:
        st = os.stat(src)

# According to David Ascher <da@ski.org>, utime() should be done
        # before chmod() (at least under NT).
        if preserve_times:
            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
        if preserve_mode:
            os.chmod(dst, S_IMODE(st[ST_MODE]))

return (dst, 1)

# XXX I suspect this is Unix-specific -- need porting help!
def move_file (src, dst, verbose=1, dry_run=0):
    """Move a file 'src' to 'dst'.

If 'dst' is a directory, the file will be moved into it with the same
    name; otherwise, 'src' is just renamed to 'dst'.  Return the new
    full name of the file.

Handles cross-device moves on Unix using 'copy_file()'.  What about
    other systems???
    """
    from os.path import exists, isfile, isdir, basename, dirname
    import errno

if verbose >= 1:
        log.info("moving %s -> %s", src, dst)

if dry_run:
        return dst

if not isfile(src):
        raise DistutilsFileError("can't move '%s': not a regular file" % src)

if isdir(dst):
        dst = os.path.join(dst, basename(src))
    elif exists(dst):
        raise DistutilsFileError(
              "can't move '%s': destination '%s' already exists" %
              (src, dst))

if not isdir(dirname(dst)):
        raise DistutilsFileError(
              "can't move '%s': destination '%s' not a valid path" % \
              (src, dst))

copy_it = 0
    try:
        os.rename(src, dst)
    except os.error, (num, msg):
        if num == errno.EXDEV:
            copy_it = 1
        else:
            raise DistutilsFileError(
                  "couldn't move '%s' to '%s': %s" % (src, dst, msg))

if copy_it:
        copy_file(src, dst, verbose=verbose)
        try:
            os.unlink(src)
        except os.error, (num, msg):
            try:
                os.unlink(dst)
            except os.error:
                pass
            raise DistutilsFileError(
                  ("couldn't move '%s' to '%s' by copy/delete: " +
                   "delete '%s' failed: %s") %
                  (src, dst, src, msg))
    return dst

def write_file (filename, contents):
    """Create a file with the specified name and write 'contents' (a
    sequence of strings without line terminators) to it.
    """
    f = open(filename, "w")
    try:
        for line in contents:
            f.write(line + "\n")
    finally:
        f.close()
file_util.pyc000064400000015136151702014350007241 0ustar00�
{fc@s�dZdZddlZddlmZddlmZidd6dd6d	d
6Zdd
�Z	ddddddd�Z
ddd�Zd�ZdS(sFdistutils.file_util

Utility functions for operating on single files.
s$Id$i����N(tDistutilsFileError(tlogtcopyingshard linkingthardssymbolically linkingtsymiicCs�d}d}z�yt|d�}Wn2tjk
rV\}}td||f��nXtjj|�r�ytj|�Wq�tjk
r�\}}td||f��q�Xnyt|d�}Wn2tjk
r�\}}td||f��nXx�y|j|�}Wn2tjk
rD\}}td||f��nX|sOPny|j	|�Wq�tjk
r�\}}td||f��q�Xq�WWd|r�|j
�n|r�|j
�nXdS(	s5Copy the file 'src' to 'dst'.

Both must be filenames. Any error opening either file, reading from
    'src', or writing to 'dst', raises DistutilsFileError.  Data is
    read/written in chunks of 'buffer_size' bytes (default 16k).  No attempt
    is made to handle anything apart from regular files.
    trbscould not open '%s': %sscould not delete '%s': %stwbscould not create '%s': %sscould not read from '%s': %sscould not write to '%s': %sN(tNonetopentosterrorRtpathtexiststunlinktreadtwritetclose(tsrctdsttbuffer_sizetfsrctfdstterrnoterrstrtbuf((s+/usr/lib64/python2.7/distutils/file_util.pyt_copy_file_contentssF

iicCs�ddlm}ddlm}	m}
m}m}tjj	|�sWt
d|��ntjj|�r�|}
tjj|tjj
|��}ntjj|�}
|r�|||�r�|dkr�tjd|�n|dfSyt|}Wn!tk
rtd|��nX|dkrxtjj
|�tjj
|�kr_tjd	|||
�qxtjd	|||�n|r�|dfS|d
kr�tjj|�o�tjj||�sCytj||�|dfSWq�tk
r�q�XqCnP|dkrCtjj|�o#tjj||�sCtj||�|dfSnt||�|s\|r�tj|�}|r�tj|||	||
f�n|r�tj||||��q�n|dfS(sCopy a file 'src' to 'dst'.

Under Mac OS, uses the native file copy function in macostools; on
    other systems, uses '_copy_file_contents()' to copy file contents.

Return a tuple (dest_name, copied): 'dest_name' is the actual name of
    the output file, and 'copied' is true if the file was copied (or would
    have been copied, if 'dry_run' true).
    i����(tnewer(tST_ATIMEtST_MTIMEtST_MODEtS_IMODEs4can't copy '%s': doesn't exist or not a regular fileis"not copying %s (output up-to-date)is&invalid value '%s' for 'link' arguments%s %s -> %sRR(tdistutils.dep_utilRtstatRRRRR	RtisfileRtisdirtjointbasenametdirnameRtdebugt_copy_actiontKeyErrort
ValueErrortinfoRtsamefiletlinktOSErrortsymlinkRtutimetchmod(RRt
preserve_modetpreserve_timestupdateR,tverbosetdry_runRRRRRtdirtactiontst((s+/usr/lib64/python2.7/distutils/file_util.pyt	copy_fileGsT""$

$
'
'

! c
Cs�ddlm}m}m}m}m}ddl}	|dkrVtjd||�n|r`|S||�st	d|��n||�r�t
jj|||��}n%||�r�t	d||f��n|||��s�t	d||f��nd	}
yt
j
||�WnMt
jk
rb\}}||	jkrFd}
qct	d
|||f��nX|
r�t||d|�yt
j|�Wq�t
jk
r�\}}yt
j|�Wnt
jk
r�nXt	dd
||||f��q�Xn|S(s)Move a file 'src' to 'dst'.

If 'dst' is a directory, the file will be moved into it with the same
    name; otherwise, 'src' is just renamed to 'dst'.  Return the new
    full name of the file.

Handles cross-device moves on Unix using 'copy_file()'.  What about
    other systems???
    i����(RR!R"R$R%Nismoving %s -> %ss#can't move '%s': not a regular files0can't move '%s': destination '%s' already existss2can't move '%s': destination '%s' not a valid pathiscouldn't move '%s' to '%s': %sR4s+couldn't move '%s' to '%s' by copy/delete: sdelete '%s' failed: %s(tos.pathRR!R"R$R%RRR*RR	RR#trenameR
tEXDEVR9R
(
RRR4R5RR!R"R$R%Rtcopy_ittnumtmsg((s+/usr/lib64/python2.7/distutils/file_util.pyt	move_file�sP
(	cCsGt|d�}z&x|D]}|j|d�qWWd|j�XdS(s{Create a file with the specified name and write 'contents' (a
    sequence of strings without line terminators) to it.
    tws
N(RRR(tfilenametcontentstftline((s+/usr/lib64/python2.7/distutils/file_util.pyt
write_file�s

i@(
t__doc__t__revision__R	tdistutils.errorsRt	distutilsRRR'RR9R@RF(((s+/usr/lib64/python2.7/distutils/file_util.pyt<module>s

5	b<file_util.pyo000064400000015136151702014350007255 0ustar00�
{fc@s�dZdZddlZddlmZddlmZidd6dd6d	d
6Zdd
�Z	ddddddd�Z
ddd�Zd�ZdS(sFdistutils.file_util

Both must be filenames. Any error opening either file, reading from
    'src', or writing to 'dst', raises DistutilsFileError.  Data is
    read/written in chunks of 'buffer_size' bytes (default 16k).  No attempt
    is made to handle anything apart from regular files.
    trbscould not open '%s': %sscould not delete '%s': %stwbscould not create '%s': %sscould not read from '%s': %sscould not write to '%s': %sN(tNonetopentosterrorRtpathtexiststunlinktreadtwritetclose(tsrctdsttbuffer_sizetfsrctfdstterrnoterrstrtbuf((s+/usr/lib64/python2.7/distutils/file_util.pyt_copy_file_contentssF

Under Mac OS, uses the native file copy function in macostools; on
    other systems, uses '_copy_file_contents()' to copy file contents.

$
'
'

If 'dst' is a directory, the file will be moved into it with the same
    name; otherwise, 'src' is just renamed to 'dst'.  Return the new
    full name of the file.

i@(
t__doc__t__revision__R	tdistutils.errorsRt	distutilsRRR'RR9R@RF(((s+/usr/lib64/python2.7/distutils/file_util.pyt<module>s

5	b<log.pyc000064400000005342151702014350006044 0ustar00�
{fc@s�dZdZdZdZdZdZddlZddd	��YZe�Zej	Z	ej
Z
ejZejZej
Z
ejZd
�Zd�ZdS(
s,A simple log mechanism styled after PEP 282.iiiiii����NtLogcBsSeZed�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
RS(cCs
||_dS(N(t	threshold(tselfR((s%/usr/lib64/python2.7/distutils/log.pyt__init__scCs�|tttttfkr4tdt|���n||jkr�|rV||}n|tttfkrwtj	}n	tj
}|jd|�|j�ndS(Ns%s wrong log levels%s
(
tDEBUGtINFOtWARNtERRORtFATALt
ValueErrortstrRtsyststderrtstdouttwritetflush(Rtleveltmsgtargststream((s%/usr/lib64/python2.7/distutils/log.pyt_logs
	cGs|j|||�dS(N(R(RRRR((s%/usr/lib64/python2.7/distutils/log.pytlog!scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pytdebug$scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pytinfo'scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pytwarn*scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pyterror-scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pytfatal0s(t__name__t
__module__RRRRRRRRR(((s%/usr/lib64/python2.7/distutils/log.pyRs						cCstj}|t_|S(N(t_global_logR(Rtold((s%/usr/lib64/python2.7/distutils/log.pyt
set_threshold;s		cCsO|dkrtt�n2|dkr2tt�n|dkrKtt�ndS(Niii(RRRR(tv((s%/usr/lib64/python2.7/distutils/log.pyt
set_verbosityAs

((t__doc__RRRRRRRRRRRRRRRR!(((s%/usr/lib64/python2.7/distutils/log.pyt<module>s %								msvc9compiler.pyc000064400000051771151702014350010066 0ustar00�
{fc@s�dZdZddlZddlZddlZddlZddlmZmZm	Z	m
Z
mZddlm
Z
mZddlmZddlmZddlZejZejZejZejZejejejejfZ ej!dkoej"d%kZ#e#r'dZ$dZ%d
Z&dZ'ndZ$dZ%dZ&dZ'idd6dd6dd6Z(dd&d��YZ)dd'd��YZ*d�Z+d�Z,d�Z-d�Z.dd �Z/e+�Z0e0d!kr�ed"e0��nd#e
fd$��YZ1dS((sdistutils.msvc9compiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio 2008.

The module is compatible with VS 2005 and VS 2008. You can find legacy support
for older versions of VS in distutils.msvccompiler.
s$Id$i����N(tDistutilsExecErrortDistutilsPlatformErrortCompileErrortLibErrort	LinkError(t	CCompilertgen_lib_options(tlog(tget_platformtwin32ii s1Software\Wow6432Node\Microsoft\VisualStudio\%0.1fs.Software\Wow6432Node\Microsoft\VCExpress\%0.1fs5Software\Wow6432Node\Microsoft\Microsoft SDKs\Windowss,Software\Wow6432Node\Microsoft\.NETFrameworks%Software\Microsoft\VisualStudio\%0.1fs"Software\Microsoft\VCExpress\%0.1fs)Software\Microsoft\Microsoft SDKs\Windowss Software\Microsoft\.NETFrameworktx86tamd64s	win-amd64tia64swin-ia64tRegcBsbeZdZd�Zee�Zd�Zee�Zd�Zee�Zd�Zee�ZRS(s2Helper class to read values from the registry
    cCsMx:tD]2}|j||�}|r||kr||SqWt|��dS(N(tHKEYStread_valuestKeyError(tclstpathtkeytbasetd((s//usr/lib64/python2.7/distutils/msvc9compiler.pyt	get_valueDs

cCs�yt||�}Wntk
r'dSXg}d}xItryt||�}Wntk
rdPnX|j|�|d7}q7W|S(sReturn list of registry keys.iiN(tRegOpenKeyExtRegErrortNonetTruet
RegEnumKeytappend(RRRthandletLtitk((s//usr/lib64/python2.7/distutils/msvc9compiler.pyt	read_keysLs

c	Cs�yt||�}Wntk
r'dSXi}d}xmtr�yt||�\}}}Wntk
rmPnX|j�}|j|�||j|�<|d7}q7W|S(s`Return dict of registry keys and values.

All names are converted to lowercase.
        iiN(RRRRtRegEnumValuetlowertconvert_mbcs(	RRRRRRtnametvaluettype((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR^s
	
cCsIt|dd�}|dk	rEy|d�}WqEtk
rAqEXn|S(Ntdecodetmbcs(tgetattrRtUnicodeError(tstdec((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR$ts
(	t__name__t
__module__t__doc__RtclassmethodR!RR$tstaticmethod(((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR
@s				t
MacroExpandercBs,eZd�Zd�Zd�Zd�ZRS(cCs'i|_t||_|j|�dS(N(tmacrostVS_BASEtvsbasetload_macros(tselftversion((s//usr/lib64/python2.7/distutils/msvc9compiler.pyt__init__�s	
cCs!tj||�|jd|<dS(Ns$(%s)(R
RR4(R8tmacroRR((s//usr/lib64/python2.7/distutils/msvc9compiler.pyt	set_macro�scCsR|jd|jdd�|jd|jdd�|jdtd�y2|dkrl|jd	td
�ntd
��Wntk
r�td��nX|dkr�|jd
|jd�|jdtd�n}d}xttD]l}yt||�}Wntk
r
q�nXt	|d�}t
j|d||f�}|d|jd<q�WdS(NtVCInstallDirs	\Setup\VCt
productdirtVSInstallDirs	\Setup\VStFrameworkDirtinstallrootg @tFrameworkSDKDirssdkinstallrootv2.0sPython was built with Visual Studio 2008;
extensions must be built with a compiler than can generate compatible binaries.
Visual Studio 2008 was not found on this system. If you have Cygwin installed,
you can try compiling with MingW32, by passing "-c mingw32" to setup.py.g"@tFrameworkVersionsclr versiont
WindowsSdkDirtcurrentinstallfolders.Software\Microsoft\NET Framework Setup\Productis%s\%sR9s$(FrameworkVersion)(
R<R6tNET_BASERRtWINSDK_BASERRRRR
RR4(R8R9tpRthRR((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR7�s.

cCs6x/|jj�D]\}}|j||�}qW|S(N(R4titemstreplace(R8R,R tv((s//usr/lib64/python2.7/distutils/msvc9compiler.pytsub�s(R.R/R:R<R7RM(((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR3~s			cCs�d}tjj|�}|dkr(dS|t|�}tj|jdd�\}}t|d �d}t|dd!�d	}|dkr�d
}n|dkr�||SdS(s�Return the version of MSVC that was used to build Python.

For Python 2.3 and up, the version number is included in
    sys.version.  For earlier versions, assume the compiler is MSVC 6.
    sMSC v.i����it ii����iig$@iN(tsysR9tfindtlentsplittintR(tprefixRR,tresttmajorVersiontminorVersion((s//usr/lib64/python2.7/distutils/msvc9compiler.pytget_build_version�s	cCsIg}x<|D]4}tjj|�}||kr
|j|�q
q
W|S(snReturn a list of normalized paths with duplicates removed.

The current order of paths is maintained.
    (tosRtnormpathR(tpathst
reduced_pathsRHtnp((s//usr/lib64/python2.7/distutils/msvc9compiler.pytnormalize_and_reduce_paths�s
cCs[|jtj�}g}x*|D]"}||kr|j|�qqWtjj|�}|S(s8Remove duplicate values of an environment variable.
    (RRRYtpathsepRtjoin(tvariabletoldListtnewListRtnewVariable((s//usr/lib64/python2.7/distutils/msvc9compiler.pytremoveDuplicates�s
cCs�t|}ytjd|d�}Wntk
r=d}nX|dkr�t|}ytjd|d�}Wq�tk
r�d}tjd�q�Xn|s�tj	j
|�rZd|}tjj|d�}|rFtj	j
|�rFtj	j
|tjtjd�}tj	j|�}tj	j
|�sWtjd|�dSqZtjd|�n|sqtjd�dStj	j
|d	�}tj	j|�r�|Stjd
�dS(s�Find the vcvarsall.bat file

At first it tries to find the productdir of VS 2008 in the registry. If
    that fails it falls back to the VS90COMNTOOLS env var.
    s%s\Setup\VCR>s%Unable to find productdir in registrysVS%0.f0COMNTOOLStVCs%s is not a valid directorys Env var %s is not set or invalidsNo productdir founds
vcvarsall.batsUnable to find vcvarsall.batN(R5R
RRRtVSEXPRESS_BASERtdebugRYRtisdirtenvirontgetR`tpardirtabspathtisfile(R9R6R>ttoolskeyttoolsdirt	vcvarsall((s//usr/lib64/python2.7/distutils/msvc9compiler.pytfind_vcvarsall�s@

cCs�t|�}td�}i}|dkr9td��ntjd||�tjd||fdtjd	tj�}z�|j	�\}}|j
�d
kr�t|jd���n|jd�}x�|jd�D]�}t
j|�}d
|kr�q�n|j�}|jd
d�\}	}
|	j�}	|	|kr�|
jtj�rW|
d }
nt|
�||	<q�q�WWd|jj�|jj�Xt|�t|�kr�ttt|j�����n|S(sDLaunch vcvarsall.bat and read the settings from its environment
    tincludetlibtlibpathRsUnable to find vcvarsall.bats'Calling 'vcvarsall.bat %s' (version=%s)s
"%s" %s & settstdouttstderriR)s
t=ii����N(RsRtRuR(RrtsetRRRRht
subprocesstPopentPIPEtcommunicatetwaitR(RRR
R$tstripR#tendswithRYR_ReRvtcloseRwRQt
ValueErrortstrtlisttkeys(R9tarchRqtinterestingtresulttpopenRvRwtlineRR&((s//usr/lib64/python2.7/distutils/msvc9compiler.pytquery_vcvarsalls<

!g @s(VC %0.1f is not supported by this moduletMSVCCompilercBsMeZdZdZiZdgZdddgZdgZdgZeeeeZ	dZ
d	Zd
ZdZ
dZZd
Zdddd�Zdd�Zddd�Zdddddddd�Zdddd�Zddddddddddd�
Zd�Zd�Zd�Zd�Zd�Zd�Zdd�Zd�ZRS(swConcrete class that implements an interface to Microsoft Visual C++,
       as defined by the CCompiler abstract class.tmsvcs.cs.ccs.cpps.cxxs.rcs.mcs.ress.objs.libs.dlls%s%ss.exeicCsPtj||||�t|_d|_g|_d|_d|_t	|_
dS(NsSoftware\Microsoft\VisualStudio(RR:tVERSIONt_MSVCCompiler__versiont_MSVCCompiler__roott_MSVCCompiler__pathsRt	plat_namet_MSVCCompiler__archtFalsetinitialized(R8tverbosetdry_runtforce((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR:Ss					cCs+|jstd��|dkr.t�}nd%}||krVtd|f��ndtjkr�dtjkr�|jd�r�d|_d	|_	d
|_
d|_d|_n+|t�ks�|dkr�t
|}nt
t�d
t
|}tt|�}|djd�jtj�|_|djd�tjd<|djd�tjd<t|j�dkr�td|j��n|jd�|_|jd	�|_	|jd
�|_
|jd�|_|jd�|_y5x.tjdjd�D]}|jj|�q�WWntk
r&nXt|j�|_dj|j�tjd<d|_|jdkr�dddddg|_ddddddg|_n9ddddddg|_dddddddg|_d dd!g|_|jd"krd dd#d$g|_ ndg|_!t"|_dS(&Nsdon't init multiple timesR	s	win-amd64swin-ia64s--plat-name must be one of %stDISTUTILS_USE_SDKtMSSdkscl.exeslink.exeslib.exesrc.exesmc.exet_RR)RtRsisxPython was built with %s, and extensions need to be built with the same version of the compiler, but it isn't installed.t;R
s/nologos/Oxs/MDs/W3s/DNDEBUGs/Ods/MDds/Z7s/D_DEBUGs/GS-s/DLLs/INCREMENTAL:NOis/INCREMENTAL:nos/DEBUG(R	s	win-amd64swin-ia64(#R�tAssertionErrorRRRRYRjtfind_exetcctlinkerRttrctmctPLAT_TO_VCVARSR�R�tencodeRRR_R�RQt_MSVCCompiler__productRRR^R`tpreprocess_optionsR�tcompile_optionstcompile_options_debugtldflags_sharedR�tldflags_shared_debugtldflags_staticR(R8R�tok_platst	plat_spectvc_envRH((s//usr/lib64/python2.7/distutils/msvc9compiler.pyt
initialize^sf-				
"
	tcCs>|dkrd}ng}x|D]}tjj|�\}}tjj|�d}|tjj|�}||jkr�td|��n|r�tjj|�}n||j	kr�|j
tjj|||j��q"||j
kr|j
tjj|||j��q"|j
tjj|||j��q"W|S(NR�isDon't know how to compile %s(RRYRtsplitextt
splitdrivetisabstsrc_extensionsRtbasenamet_rc_extensionsRR`t
res_extensiont_mc_extensionst
obj_extension(R8tsource_filenamest	strip_dirt
output_dirt	obj_namestsrc_nameRtext((s//usr/lib64/python2.7/distutils/msvc9compiler.pytobject_filenames�s(	
c	Cs�|js|j�n|j||||||�}	|	\}}
}}}|pRg}
|
jd�|r{|
j|j�n|
j|j�xV|
D]N}y||\}}Wntk
r�q�nX|r�tj	j
|�}n||jkr�d|}n�||jkrd|}nq||j
kr�|}d|}y)|j|jg||g|g�Wq�tk
r}t|��q�Xq�n||jkrqtj	j|�}tj	j|�}y�|j|jgd|d|g|g�tj	jtj	j|��\}}tj	j||d�}|j|jgd|g|g�Wq�tk
rj}t|��q�Xq�ntd||f��d	|}y-|j|jg|
|||g|�Wq�tk
r�}t|��q�Xq�W|
S(
Ns/cs/Tcs/Tps/fos-hs-rs.rcs"Don't know how to compile %s to %ss/Fo(R�R�t_setup_compileRtextendR�R�RRYRRmt
_c_extensionst_cpp_extensionsR�tspawnR�RRR�tdirnameR�R�R�R`R�(R8tsourcesR�R4tinclude_dirsRht
extra_preargstextra_postargstdependstcompile_infotobjectstpp_optstbuildtcompile_optstobjtsrcR�t	input_optt
output_opttmsgth_dirtrc_dirRR�trc_file((s//usr/lib64/python2.7/distutils/msvc9compiler.pytcompile�sj

#$$#
c	Cs�|js|j�n|j||�\}}|j|d|�}|j||�r�|d|g}|rony|j|jg|�Wq�tk
r�}t|��q�Xnt	j
d|�dS(NR�s/OUT:sskipping %s (up-to-date)(R�R�t_fix_object_argstlibrary_filenamet
_need_linkR�RtRRRRh(	R8R�toutput_libnameR�Rhttarget_langtoutput_filenametlib_argsR�((s//usr/lib64/python2.7/distutils/msvc9compiler.pytcreate_static_lib)s	
	cCs�|js|j�n|j||�\}}|j|||�}|\}}}|rr|jdt|��nt||||�}|dk	r�tj	j
||�}n|j||�r�|tj
kr�|	r�|jd}q
|jd}n|	r|j}n	|j}g}x%|pgD]}|jd|�q W||||d|g}tj	j|d�}|dk	r�tj	jtj	j|��\}}tj	j
||j|��}|jd|�n|j|||�|
r�|
|d*n|r|j|�n|jtj	j|��y|j|jg|�Wntk
ra}t|��nX|j||�}|dk	r�|\}}d||f}y |jdd	d
||g�Wq�tk
r�}t|��q�Xq�ntjd|�dS(Ns5I don't know what to do with 'runtime_library_dirs': is/EXPORT:s/OUT:is/IMPLIB:s-outputresource:%s;%ssmt.exes-nologos	-manifestsskipping %s (up-to-date)(R�R�R�t
_fix_lib_argstwarnR�RRRYRR`R�Rt
EXECUTABLER�R�RR�R�R�R�tmanifest_setup_ldargsR�tmkpathR�R�RRtmanifest_get_embed_infoRRh(R8ttarget_descR�R�R�t	librariestlibrary_dirstruntime_library_dirstexport_symbolsRhR�R�t
build_tempR�t
fixed_argstlib_optstldflagstexport_optstsymtld_argstdll_nametdll_exttimplib_fileR�tmfinfot
mffilenametmfidtout_arg((s//usr/lib64/python2.7/distutils/msvc9compiler.pytlinkBsl	
						
cCs:tjj|tjj|�d�}|jd|�dS(Ns	.manifests/MANIFESTFILE:(RYRR`R�R(R8R�R�R�t
temp_manifest((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR��s	cCs�x;|D]/}|jd�r|jdd�d}PqqWdS|tjkrVd}nd}|j|�}|dkr{dS||fS(Ns/MANIFESTFILE:t:ii(t
startswithRRRRR�t_remove_visual_c_ref(R8R�R�targR�R�((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR��s
	cCs�y�t|�}z|j�}Wd|j�Xtjdtj�}tj|d|�}d}tj|d|�}tjdtj�}tj||�dkr�dSt|d�}z|j	|�|SWd|j�XWnt
k
r�nXdS(NsU<assemblyIdentity.*?name=("|')Microsoft\.VC\d{2}\.CRT("|').*?(/>|</assemblyIdentity>)R�s*<dependentAssembly>\s*</dependentAssembly>sI<assemblyIdentity.*?name=(?:"|')(.+?)(?:"|').*?(?:/>|</assemblyIdentity>)tw(topentreadR�treR�tDOTALLRMtsearchRtwritetIOError(R8t
manifest_filet
manifest_ftmanifest_buftpattern((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR��s.

cCsd|S(Ns	/LIBPATH:((R8tdir((s//usr/lib64/python2.7/distutils/msvc9compiler.pytlibrary_dir_option�scCstd��dS(Ns<don't know how to set runtime library search path for MSVC++(R(R8R
((s//usr/lib64/python2.7/distutils/msvc9compiler.pytruntime_library_dir_option�scCs
|j|�S(N(R�(R8Rt((s//usr/lib64/python2.7/distutils/msvc9compiler.pytlibrary_option�scCs�|r|d|g}n	|g}xW|D]K}xB|D]:}tjj||j|��}tjj|�r6|Sq6Wq)WdSdS(Nt_d(RYRR`R�texistsR(R8tdirsRtRht	try_namesR
R%tlibfile((s//usr/lib64/python2.7/distutils/msvc9compiler.pytfind_library_file�s

cCs�xH|jD]=}tjjtjj|�|�}tjj|�r
|Sq
WxUtjdjd�D]=}tjjtjj|�|�}tjj|�rb|SqbW|S(s�Return path to an MSVC executable program.

Tries to find the program in several places: first, one of the
        MSVC program search paths from the registry; next, the directories
        in the PATH environment variable.  If any of those work, return an
        absolute path that is known to exist.  If none of them work, just
        return the original program name, 'exe'.
        tPathR�(R�RYRR`RmRnRjRR(R8texeRHtfn((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR�
s	!!N( R.R/R0t
compiler_typetexecutablesR�R�R�R�R�R�R�tstatic_lib_extensiontshared_lib_extensiontstatic_lib_formattshared_lib_formatt
exe_extensionR:RR�R�R�R�R�R�R�R�RRRRR�(((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR�5sR			
YVR			+			I(((2R0t__revision__RYRzRORtdistutils.errorsRRRRRtdistutils.ccompilerRRt	distutilsRtdistutils.utilRt_winregt	OpenKeyExRtEnumKeyRt	EnumValueR"terrorRt
HKEY_USERStHKEY_CURRENT_USERtHKEY_LOCAL_MACHINEtHKEY_CLASSES_ROOTRtplatformtmaxsizetNATIVE_WIN64R5RgRGRFR�R
R3RXR^ReRrR�R�R�(((s//usr/lib64/python2.7/distutils/msvc9compiler.pyt<module>sV(					
>.				,)	msvc9compiler.pyo000064400000051660151702014350010077 0ustar00�
{fc@s�dZdZddlZddlZddlZddlZddlmZmZm	Z	m
Z
mZddlm
Z
mZddlmZddlmZddlZejZejZejZejZejejejejfZ ej!dkoej"d%kZ#e#r'dZ$dZ%d
Z&dZ'ndZ$dZ%dZ&dZ'idd6dd6dd6Z(dd&d��YZ)dd'd��YZ*d�Z+d�Z,d�Z-d�Z.dd �Z/e+�Z0e0d!kr�ed"e0��nd#e
fd$��YZ1dS((sdistutils.msvc9compiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio 2008.

c	Cs�yt||�}Wntk
r'dSXi}d}xmtr�yt||�\}}}Wntk
rmPnX|j�}|j|�||j|�<|d7}q7W|S(s`Return dict of registry keys and values.

!g @s(VC %0.1f is not supported by this moduletMSVCCompilercBsMeZdZdZiZdgZdddgZdgZdgZeeeeZ	dZ
d	Zd
ZdZ
dZZd
Zdddd�Zdd�Zddd�Zdddddddd�Zdddd�Zddddddddddd�
Zd�Zd�Zd�Zd�Zd�Zd�Zdd�Zd�ZRS(swConcrete class that implements an interface to Microsoft Visual C++,
       as defined by the CCompiler abstract class.tmsvcs.cs.ccs.cpps.cxxs.rcs.mcs.ress.objs.libs.dlls%s%ss.exeicCsPtj||||�t|_d|_g|_d|_d|_t	|_
dS(NsSoftware\Microsoft\VisualStudio(RR:tVERSIONt_MSVCCompiler__versiont_MSVCCompiler__roott_MSVCCompiler__pathsRt	plat_namet_MSVCCompiler__archtFalsetinitialized(R8tverbosetdry_runtforce((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR:Ss					cCs|dkrt�}nd$}||kr@td|f��ndtjkr�dtjkr�|jd�r�d|_d|_d	|_d
|_	d|_
n+|t�ks�|dkr�t|}ntt�dt|}tt
|�}|d
jd�jtj�|_|djd�tjd<|djd�tjd<t|j�dkrntd|j��n|jd�|_|jd�|_|jd	�|_|jd
�|_	|jd�|_
y5x.tjd
jd�D]}|jj|�q�WWntk
rnXt|j�|_dj|j�tjd
<d|_|jdkr�dddddg|_ddddddg|_n9ddddddg|_dddddddg|_ddd g|_|jd!kr�ddd"d#g|_ndg|_t |_!dS(%NR	s	win-amd64swin-ia64s--plat-name must be one of %stDISTUTILS_USE_SDKtMSSdkscl.exeslink.exeslib.exesrc.exesmc.exet_RR)RtRsisxPython was built with %s, and extensions need to be built with the same version of the compiler, but it isn't installed.t;R
s/nologos/Oxs/MDs/W3s/DNDEBUGs/Ods/MDds/Z7s/D_DEBUGs/GS-s/DLLs/INCREMENTAL:NOis/INCREMENTAL:nos/DEBUG(R	s	win-amd64swin-ia64("RRRRYRjtfind_exetcctlinkerRttrctmctPLAT_TO_VCVARSR�R�tencodeRRR_R�RQt_MSVCCompiler__productRRR^R`tpreprocess_optionsR�tcompile_optionstcompile_options_debugtldflags_sharedR�tldflags_shared_debugtldflags_staticRR�(R8R�tok_platst	plat_spectvc_envRH((s//usr/lib64/python2.7/distutils/msvc9compiler.pyt
initialize^sd-				
"
	tcCs>|dkrd}ng}x|D]}tjj|�\}}tjj|�d}|tjj|�}||jkr�td|��n|r�tjj|�}n||j	kr�|j
tjj|||j��q"||j
kr|j
tjj|||j��q"|j
tjj|||j��q"W|S(NR�isDon't know how to compile %s(RRYRtsplitextt
splitdrivetisabstsrc_extensionsRtbasenamet_rc_extensionsRR`t
res_extensiont_mc_extensionst
obj_extension(R8tsource_filenamest	strip_dirt
output_dirt	obj_namestsrc_nameRtext((s//usr/lib64/python2.7/distutils/msvc9compiler.pytobject_filenames�s(	
c	Cs�|js|j�n|j||||||�}	|	\}}
}}}|pRg}
|
jd�|r{|
j|j�n|
j|j�xV|
D]N}y||\}}Wntk
r�q�nX|r�tj	j
|�}n||jkr�d|}n�||jkrd|}nq||j
kr�|}d|}y)|j|jg||g|g�Wq�tk
r}t|��q�Xq�n||jkrqtj	j|�}tj	j|�}y�|j|jgd|d|g|g�tj	jtj	j|��\}}tj	j||d�}|j|jgd|g|g�Wq�tk
rj}t|��q�Xq�ntd||f��d	|}y-|j|jg|
|||g|�Wq�tk
r�}t|��q�Xq�W|
S(
Ns/cs/Tcs/Tps/fos-hs-rs.rcs"Don't know how to compile %s to %ss/Fo(R�R�t_setup_compileRtextendR�R�RRYRRmt
_c_extensionst_cpp_extensionsR�tspawnR�RRR�tdirnameR�R�R�R`R�(R8tsourcesR�R4tinclude_dirsRht
extra_preargstextra_postargstdependstcompile_infotobjectstpp_optstbuildtcompile_optstobjtsrcR�t	input_optt
output_opttmsgth_dirtrc_dirRR�trc_file((s//usr/lib64/python2.7/distutils/msvc9compiler.pytcompile�sj

cCsd|S(Ns	/LIBPATH:((R8tdir((s//usr/lib64/python2.7/distutils/msvc9compiler.pytlibrary_dir_option�scCstd��dS(Ns<don't know how to set runtime library search path for MSVC++(R(R8R((s//usr/lib64/python2.7/distutils/msvc9compiler.pytruntime_library_dir_option�scCs
|j|�S(N(R�(R8Rt((s//usr/lib64/python2.7/distutils/msvc9compiler.pytlibrary_option�scCs�|r|d|g}n	|g}xW|D]K}xB|D]:}tjj||j|��}tjj|�r6|Sq6Wq)WdSdS(Nt_d(RYRR`R�texistsR(R8tdirsRtRht	try_namesRR%tlibfile((s//usr/lib64/python2.7/distutils/msvc9compiler.pytfind_library_file�s

cCs�xH|jD]=}tjjtjj|�|�}tjj|�r
|Sq
WxUtjdjd�D]=}tjjtjj|�|�}tjj|�rb|SqbW|S(s�Return path to an MSVC executable program.

Tries to find the program in several places: first, one of the
        MSVC program search paths from the registry; next, the directories
        in the PATH environment variable.  If any of those work, return an
        absolute path that is known to exist.  If none of them work, just
        return the original program name, 'exe'.
        tPathR�(R�RYRR`RmRnRjRR(R8texeRHtfn((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR�
s	!!N( R.R/R0t
compiler_typetexecutablesR�R�R�R�R�R�R�tstatic_lib_extensiontshared_lib_extensiontstatic_lib_formattshared_lib_formatt
exe_extensionR:RR�R�R�R�R�R�R�R�R
RRRR�(((s//usr/lib64/python2.7/distutils/msvc9compiler.pyR�5sR			
YVR			+			I(((2R0t__revision__RYRzRORtdistutils.errorsRRRRRtdistutils.ccompilerRRt	distutilsRtdistutils.utilRt_winregt	OpenKeyExRtEnumKeyRt	EnumValueR"terrorRt
HKEY_USERStHKEY_CURRENT_USERtHKEY_LOCAL_MACHINEtHKEY_CLASSES_ROOTRtplatformtmaxsizetNATIVE_WIN64R5RgRGRFR�R
R3RXR^ReRrR�R�R�(((s//usr/lib64/python2.7/distutils/msvc9compiler.pyt<module>sV(					
>.				,)	msvccompiler.py000064400000056125151702014350007630 0ustar00"""distutils.msvccompiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio.
"""

# Written by Perry Stoll
# hacked by Robin Becker and Thomas Heller to do a better job of
#   finding DevStudio (through the registry)

__revision__ = "$Id$"

import sys
import os
import string

from distutils.errors import (DistutilsExecError, DistutilsPlatformError,
                              CompileError, LibError, LinkError)
from distutils.ccompiler import CCompiler, gen_lib_options
from distutils import log

_can_read_reg = 0
try:
    import _winreg

_can_read_reg = 1
    hkey_mod = _winreg

RegOpenKeyEx = _winreg.OpenKeyEx
    RegEnumKey = _winreg.EnumKey
    RegEnumValue = _winreg.EnumValue
    RegError = _winreg.error

except ImportError:
    try:
        import win32api
        import win32con
        _can_read_reg = 1
        hkey_mod = win32con

RegOpenKeyEx = win32api.RegOpenKeyEx
        RegEnumKey = win32api.RegEnumKey
        RegEnumValue = win32api.RegEnumValue
        RegError = win32api.error

except ImportError:
        log.info("Warning: Can't read registry to find the "
                 "necessary compiler setting\n"
                 "Make sure that Python modules _winreg, "
                 "win32api or win32con are installed.")
        pass

if _can_read_reg:
    HKEYS = (hkey_mod.HKEY_USERS,
             hkey_mod.HKEY_CURRENT_USER,
             hkey_mod.HKEY_LOCAL_MACHINE,
             hkey_mod.HKEY_CLASSES_ROOT)

def read_keys(base, key):
    """Return list of registry keys."""

try:
        handle = RegOpenKeyEx(base, key)
    except RegError:
        return None
    L = []
    i = 0
    while 1:
        try:
            k = RegEnumKey(handle, i)
        except RegError:
            break
        L.append(k)
        i = i + 1
    return L

def read_values(base, key):
    """Return dict of registry keys and values.

All names are converted to lowercase.
    """
    try:
        handle = RegOpenKeyEx(base, key)
    except RegError:
        return None
    d = {}
    i = 0
    while 1:
        try:
            name, value, type = RegEnumValue(handle, i)
        except RegError:
            break
        name = name.lower()
        d[convert_mbcs(name)] = convert_mbcs(value)
        i = i + 1
    return d

def convert_mbcs(s):
    enc = getattr(s, "encode", None)
    if enc is not None:
        try:
            s = enc("mbcs")
        except UnicodeError:
            pass
    return s

class MacroExpander:

def __init__(self, version):
        self.macros = {}
        self.load_macros(version)

def set_macro(self, macro, path, key):
        for base in HKEYS:
            d = read_values(base, path)
            if d:
                self.macros["$(%s)" % macro] = d[key]
                break

def load_macros(self, version):
        vsbase = r"Software\Microsoft\VisualStudio\%0.1f" % version
        self.set_macro("VCInstallDir", vsbase + r"\Setup\VC", "productdir")
        self.set_macro("VSInstallDir", vsbase + r"\Setup\VS", "productdir")
        net = r"Software\Microsoft\.NETFramework"
        self.set_macro("FrameworkDir", net, "installroot")
        try:
            if version > 7.0:
                self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv1.1")
            else:
                self.set_macro("FrameworkSDKDir", net, "sdkinstallroot")
        except KeyError:
            raise DistutilsPlatformError, \
                  ("""Python was built with Visual Studio 2003;
extensions must be built with a compiler than can generate compatible binaries.
Visual Studio 2003 was not found on this system. If you have Cygwin installed,
you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")

p = r"Software\Microsoft\NET Framework Setup\Product"
        for base in HKEYS:
            try:
                h = RegOpenKeyEx(base, p)
            except RegError:
                continue
            key = RegEnumKey(h, 0)
            d = read_values(base, r"%s\%s" % (p, key))
            self.macros["$(FrameworkVersion)"] = d["version"]

def sub(self, s):
        for k, v in self.macros.items():
            s = string.replace(s, k, v)
        return s

def get_build_version():
    """Return the version of MSVC that was used to build Python.

For Python 2.3 and up, the version number is included in
    sys.version.  For earlier versions, assume the compiler is MSVC 6.
    """

prefix = "MSC v."
    i = string.find(sys.version, prefix)
    if i == -1:
        return 6
    i = i + len(prefix)
    s, rest = sys.version[i:].split(" ", 1)
    majorVersion = int(s[:-2]) - 6
    minorVersion = int(s[2:3]) / 10.0
    # I don't think paths are affected by minor version in version 6
    if majorVersion == 6:
        minorVersion = 0
    if majorVersion >= 6:
        return majorVersion + minorVersion
    # else we don't know what version of the compiler this is
    return None

def get_build_architecture():
    """Return the processor architecture.

Possible results are "Intel", "Itanium", or "AMD64".
    """

prefix = " bit ("
    i = string.find(sys.version, prefix)
    if i == -1:
        return "Intel"
    j = string.find(sys.version, ")", i)
    return sys.version[i+len(prefix):j]

def normalize_and_reduce_paths(paths):
    """Return a list of normalized paths with duplicates removed.

The current order of paths is maintained.
    """
    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
    reduced_paths = []
    for p in paths:
        np = os.path.normpath(p)
        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
        if np not in reduced_paths:
            reduced_paths.append(np)
    return reduced_paths

class MSVCCompiler (CCompiler) :
    """Concrete class that implements an interface to Microsoft Visual C++,
       as defined by the CCompiler abstract class."""

compiler_type = 'msvc'

# Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

# Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']
    _rc_extensions = ['.rc']
    _mc_extensions = ['.mc']

# Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = (_c_extensions + _cpp_extensions +
                      _rc_extensions + _mc_extensions)
    res_extension = '.res'
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'

def __init__ (self, verbose=0, dry_run=0, force=0):
        CCompiler.__init__ (self, verbose, dry_run, force)
        self.__version = get_build_version()
        self.__arch = get_build_architecture()
        if self.__arch == "Intel":
            # x86
            if self.__version >= 7:
                self.__root = r"Software\Microsoft\VisualStudio"
                self.__macros = MacroExpander(self.__version)
            else:
                self.__root = r"Software\Microsoft\Devstudio"
            self.__product = "Visual Studio version %s" % self.__version
        else:
            # Win64. Assume this was built with the platform SDK
            self.__product = "Microsoft SDK compiler %s" % (self.__version + 6)

self.initialized = False

def initialize(self):
        self.__paths = []
        if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
            # Assume that the SDK set up everything alright; don't try to be
            # smarter
            self.cc = "cl.exe"
            self.linker = "link.exe"
            self.lib = "lib.exe"
            self.rc = "rc.exe"
            self.mc = "mc.exe"
        else:
            self.__paths = self.get_msvc_paths("path")

if len (self.__paths) == 0:
                raise DistutilsPlatformError, \
                      ("Python was built with %s, "
                       "and extensions need to be built with the same "
                       "version of the compiler, but it isn't installed." % self.__product)

self.cc = self.find_exe("cl.exe")
            self.linker = self.find_exe("link.exe")
            self.lib = self.find_exe("lib.exe")
            self.rc = self.find_exe("rc.exe")   # resource compiler
            self.mc = self.find_exe("mc.exe")   # message compiler
            self.set_path_env_var('lib')
            self.set_path_env_var('include')

# extend the MSVC path with the current path
        try:
            for p in string.split(os.environ['path'], ';'):
                self.__paths.append(p)
        except KeyError:
            pass
        self.__paths = normalize_and_reduce_paths(self.__paths)
        os.environ['path'] = string.join(self.__paths, ';')

self.preprocess_options = None
        if self.__arch == "Intel":
            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GX' ,
                                     '/DNDEBUG']
            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GX',
                                          '/Z7', '/D_DEBUG']
        else:
            # Win64
            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' ,
                                     '/DNDEBUG']
            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
                                          '/Z7', '/D_DEBUG']

self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
        if self.__version >= 7:
            self.ldflags_shared_debug = [
                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
                ]
        else:
            self.ldflags_shared_debug = [
                '/DLL', '/nologo', '/INCREMENTAL:no', '/pdb:None', '/DEBUG'
                ]
        self.ldflags_static = [ '/nologo']

self.initialized = True

# -- Worker methods ------------------------------------------------

def object_filenames (self,
                          source_filenames,
                          strip_dir=0,
                          output_dir=''):
        # Copied from ccompiler.py, extended to return .res as 'object'-file
        # for .rc input file
        if output_dir is None: output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            (base, ext) = os.path.splitext (src_name)
            base = os.path.splitdrive(base)[1] # Chop off the drive
            base = base[os.path.isabs(base):]  # If abs, chop off leading /
            if ext not in self.src_extensions:
                # Better to raise an exception instead of silently continuing
                # and later complain about sources and targets having
                # different lengths
                raise CompileError ("Don't know how to compile %s" % src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext in self._rc_extensions:
                obj_names.append (os.path.join (output_dir,
                                                base + self.res_extension))
            elif ext in self._mc_extensions:
                obj_names.append (os.path.join (output_dir,
                                                base + self.res_extension))
            else:
                obj_names.append (os.path.join (output_dir,
                                                base + self.obj_extension))
        return obj_names

# object_filenames ()

def compile(self, sources,
                output_dir=None, macros=None, include_dirs=None, debug=0,
                extra_preargs=None, extra_postargs=None, depends=None):

if not self.initialized: self.initialize()
        macros, objects, extra_postargs, pp_opts, build = \
                self._setup_compile(output_dir, macros, include_dirs, sources,
                                    depends, extra_postargs)

compile_opts = extra_preargs or []
        compile_opts.append ('/c')
        if debug:
            compile_opts.extend(self.compile_options_debug)
        else:
            compile_opts.extend(self.compile_options)

for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            if debug:
                # pass the full pathname to MSVC in debug mode,
                # this allows the debugger to find the source file
                # without asking the user to browse for it
                src = os.path.abspath(src)

# Compile .MC to .RC file to .RES file.
                #   * '-h dir' specifies the directory for the
                #     generated include file
                #   * '-r dir' specifies the target directory of the
                #     generated RC file and the binary message resource
                #     it includes
                #
                # For now (since there are no options to change this),
                # we use the source-directory for the include file and
                # the build directory for the RC file and message
                # resources. This works at least for win32all.

h_dir = os.path.dirname (src)
                rc_dir = os.path.dirname (obj)
                try:
                    # first compile .MC to .RC and .H file
                    self.spawn ([self.mc] +
                                ['-h', h_dir, '-r', rc_dir] + [src])
                    base, _ = os.path.splitext (os.path.basename (src))
                    rc_file = os.path.join (rc_dir, base + '.rc')
                    # then compile .RC to .RES file
                    self.spawn ([self.rc] +
                                ["/fo" + obj] + [rc_file])

except DistutilsExecError, msg:
                    raise CompileError, msg
                continue
            else:
                # how to handle this file?
                raise CompileError (
                    "Don't know how to compile %s to %s" % \
                    (src, obj))

output_opt = "/Fo" + obj
            try:
                self.spawn ([self.cc] + compile_opts + pp_opts +
                            [input_opt, output_opt] +
                            extra_postargs)
            except DistutilsExecError, msg:
                raise CompileError, msg

return objects

# compile ()

def create_static_lib (self,
                           objects,
                           output_libname,
                           output_dir=None,
                           debug=0,
                           target_lang=None):

if not self.initialized: self.initialize()
        (objects, output_dir) = self._fix_object_args (objects, output_dir)
        output_filename = \
            self.library_filename (output_libname, output_dir=output_dir)

if self._need_link (objects, output_filename):
            lib_args = objects + ['/OUT:' + output_filename]
            if debug:
                pass                    # XXX what goes here?
            try:
                self.spawn ([self.lib] + lib_args)
            except DistutilsExecError, msg:
                raise LibError, msg

else:
            log.debug("skipping %s (up-to-date)", output_filename)

# create_static_lib ()

def link (self,
              target_desc,
              objects,
              output_filename,
              output_dir=None,
              libraries=None,
              library_dirs=None,
              runtime_library_dirs=None,
              export_symbols=None,
              debug=0,
              extra_preargs=None,
              extra_postargs=None,
              build_temp=None,
              target_lang=None):

if not self.initialized: self.initialize()
        (objects, output_dir) = self._fix_object_args (objects, output_dir)
        (libraries, library_dirs, runtime_library_dirs) = \
            self._fix_lib_args (libraries, library_dirs, runtime_library_dirs)

if runtime_library_dirs:
            self.warn ("I don't know what to do with 'runtime_library_dirs': "
                       + str (runtime_library_dirs))

lib_opts = gen_lib_options (self,
                                    library_dirs, runtime_library_dirs,
                                    libraries)
        if output_dir is not None:
            output_filename = os.path.join (output_dir, output_filename)

if self._need_link (objects, output_filename):

if target_desc == CCompiler.EXECUTABLE:
                if debug:
                    ldflags = self.ldflags_shared_debug[1:]
                else:
                    ldflags = self.ldflags_shared[1:]
            else:
                if debug:
                    ldflags = self.ldflags_shared_debug
                else:
                    ldflags = self.ldflags_shared

export_opts = []
            for sym in (export_symbols or []):
                export_opts.append("/EXPORT:" + sym)

ld_args = (ldflags + lib_opts + export_opts +
                       objects + ['/OUT:' + output_filename])

# The MSVC linker generates .lib and .exp files, which cannot be
            # suppressed by any linker switches. The .lib files may even be
            # needed! Make sure they are generated in the temporary build
            # directory. Since they have different names for debug and release
            # builds, they can go into the same directory.
            if export_symbols is not None:
                (dll_name, dll_ext) = os.path.splitext(
                    os.path.basename(output_filename))
                implib_file = os.path.join(
                    os.path.dirname(objects[0]),
                    self.library_filename(dll_name))
                ld_args.append ('/IMPLIB:' + implib_file)

if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

self.mkpath (os.path.dirname (output_filename))
            try:
                self.spawn ([self.linker] + ld_args)
            except DistutilsExecError, msg:
                raise LinkError, msg

else:
            log.debug("skipping %s (up-to-date)", output_filename)

# link ()

# -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

def library_dir_option (self, dir):
        return "/LIBPATH:" + dir

def runtime_library_dir_option (self, dir):
        raise DistutilsPlatformError, \
              "don't know how to set runtime library search path for MSVC++"

def library_option (self, lib):
        return self.library_filename (lib)

def find_library_file (self, dirs, lib, debug=0):
        # Prefer a debugging library if found (and requested), but deal
        # with it if we don't have one.
        if debug:
            try_names = [lib + "_d", lib]
        else:
            try_names = [lib]
        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename (name))
                if os.path.exists(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None

# find_library_file ()

# Helper methods for using the MSVC registry settings

def find_exe(self, exe):
        """Return path to an MSVC executable program.

for p in self.__paths:
            fn = os.path.join(os.path.abspath(p), exe)
            if os.path.isfile(fn):
                return fn

# didn't find it; try existing path
        for p in string.split(os.environ['Path'],';'):
            fn = os.path.join(os.path.abspath(p),exe)
            if os.path.isfile(fn):
                return fn

return exe

def get_msvc_paths(self, path, platform='x86'):
        """Get a list of devstudio directories (include, lib or path).

Return a list of strings.  The list will be empty if unable to
        access the registry or appropriate registry keys not found.
        """

if not _can_read_reg:
            return []

path = path + " dirs"
        if self.__version >= 7:
            key = (r"%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directories"
                   % (self.__root, self.__version))
        else:
            key = (r"%s\6.0\Build System\Components\Platforms"
                   r"\Win32 (%s)\Directories" % (self.__root, platform))

for base in HKEYS:
            d = read_values(base, key)
            if d:
                if self.__version >= 7:
                    return string.split(self.__macros.sub(d[path]), ";")
                else:
                    return string.split(d[path], ";")
        # MSVC 6 seems to create the registry entries we need only when
        # the GUI is run.
        if self.__version == 6:
            for base in HKEYS:
                if read_values(base, r"%s\6.0" % self.__root) is not None:
                    self.warn("It seems you have Visual Studio 6 installed, "
                        "but the expected registry settings are not present.\n"
                        "You must at least run the Visual Studio GUI once "
                        "so that these entries are created.")
                    break
        return []

def set_path_env_var(self, name):
        """Set environment variable 'name' to an MSVC path type value.

This is equivalent to a SET command prior to execution of spawned
        commands.
        """

if name == "lib":
            p = self.get_msvc_paths("library")
        else:
            p = self.get_msvc_paths(name)
        if p:
            os.environ[name] = string.join(p, ';')

if get_build_version() >= 8.0:
    log.debug("Importing new compiler from distutils.msvc9compiler")
    OldMSVCCompiler = MSVCCompiler
    from distutils.msvc9compiler import MSVCCompiler
    # get_build_architecture not really relevant now we support cross-compile
    from distutils.msvc9compiler import MacroExpander
msvccompiler.pyc000064400000042165151702014350007772 0ustar00�
{fc@sdZdZddlZddlZddlZddlmZmZmZm	Z	m
Z
ddlmZm
Z
ddlmZdZy@ddlZdZeZejZejZejZejZWn~ek
rDyLddlZddlZdZeZejZejZejZejZWnek
r@ejd	�nXnXerlejej ej!ej"fZ#nd
�Z$d�Z%d�Z&d
fd��YZ'd�Z(d�Z)d�Z*defd��YZ+e(�dkrej,d�e+Z-ddl.m+Z+ddl.m'Z'ndS(s�distutils.msvccompiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio.
s$Id$i����N(tDistutilsExecErrortDistutilsPlatformErrortCompileErrortLibErrort	LinkError(t	CCompilertgen_lib_options(tlogiis�Warning: Can't read registry to find the necessary compiler setting
Make sure that Python modules _winreg, win32api or win32con are installed.cCs~yt||�}Wntk
r'dSXg}d}xCyt||�}Wntk
r^PnX|j|�|d}q7W|S(sReturn list of registry keys.iiN(tRegOpenKeyExtRegErrortNonet
RegEnumKeytappend(tbasetkeythandletLtitk((s./usr/lib64/python2.7/distutils/msvccompiler.pyt	read_keys;s

cCs�yt||�}Wntk
r'dSXi}d}xayt||�\}}}Wntk
rgPnX|j�}t|�|t|�<|d}q7W|S(sXReturn dict of registry keys and values.

All names are converted to lowercase.
    iiN(RR	R
tRegEnumValuetlowertconvert_mbcs(R
RRtdRtnametvaluettype((s./usr/lib64/python2.7/distutils/msvccompiler.pytread_valuesMs

cCsIt|dd�}|dk	rEy|d�}WqEtk
rAqEXn|S(Ntencodetmbcs(tgetattrR
tUnicodeError(tstenc((s./usr/lib64/python2.7/distutils/msvccompiler.pyRbs
t
MacroExpandercBs,eZd�Zd�Zd�Zd�ZRS(cCsi|_|j|�dS(N(tmacrostload_macros(tselftversion((s./usr/lib64/python2.7/distutils/msvccompiler.pyt__init__ms	cCsCx<tD]4}t||�}|r|||jd|<PqqWdS(Ns$(%s)(tHKEYSRR#(R%tmacrotpathRR
R((s./usr/lib64/python2.7/distutils/msvccompiler.pyt	set_macroqs

c	Cs%d|}|jd|dd�|jd|dd�d}|jd|d	�y9|d
krv|jd|d�n|jd|d
�Wntk
r�td�nXd}xqtD]i}yt||�}Wntk
r�q�nXt|d�}t|d||f�}|d|jd<q�WdS(Ns%Software\Microsoft\VisualStudio\%0.1ftVCInstallDirs	\Setup\VCt
productdirtVSInstallDirs	\Setup\VSs Software\Microsoft\.NETFrameworktFrameworkDirtinstallrootg@tFrameworkSDKDirssdkinstallrootv1.1tsdkinstallrootsPython was built with Visual Studio 2003;
extensions must be built with a compiler than can generate compatible binaries.
Visual Studio 2003 was not found on this system. If you have Cygwin installed,
you can try compiling with MingW32, by passing "-c mingw32" to setup.py.s.Software\Microsoft\NET Framework Setup\Productis%s\%sR&s$(FrameworkVersion)(	R+tKeyErrorRR(RR	RRR#(	R%R&tvsbasetnettpR
thRR((s./usr/lib64/python2.7/distutils/msvccompiler.pyR$xs*

cCs9x2|jj�D]!\}}tj|||�}qW|S(N(R#titemststringtreplace(R%R Rtv((s./usr/lib64/python2.7/distutils/msvccompiler.pytsub�s(t__name__t
__module__R'R+R$R<(((s./usr/lib64/python2.7/distutils/msvccompiler.pyR"ks			cCs�d}tjtj|�}|dkr+dS|t|�}tj|jdd�\}}t|d �d}t|dd!�d	}|dkr�d
}n|dkr�||SdS(s�Return the version of MSVC that was used to build Python.

For Python 2.3 and up, the version number is included in
    sys.version.  For earlier versions, assume the compiler is MSVC 6.
    sMSC v.i����it ii����iig$@iN(R9tfindtsysR&tlentsplittintR
(tprefixRR tresttmajorVersiontminorVersion((s./usr/lib64/python2.7/distutils/msvccompiler.pytget_build_version�s	cCs[d}tjtj|�}|dkr+dStjtjd|�}tj|t|�|!S(saReturn the processor architecture.

Possible results are "Intel", "Itanium", or "AMD64".
    s bit (i����tIntelt)(R9R@RAR&RB(RERtj((s./usr/lib64/python2.7/distutils/msvccompiler.pytget_build_architecture�scCsIg}x<|D]4}tjj|�}||kr
|j|�q
q
W|S(snReturn a list of normalized paths with duplicates removed.

The current order of paths is maintained.
    (tosR*tnormpathR(tpathst
reduced_pathsR6tnp((s./usr/lib64/python2.7/distutils/msvccompiler.pytnormalize_and_reduce_paths�s
tMSVCCompilercBsDeZdZdZiZdgZdddgZdgZdgZeeeeZ	dZ
d	Zd
ZdZ
dZZd
Zdddd�Zd�Zddd�Zdddddddd�Zdddd�Zddddddddddd�
Zd�Zd�Zd�Zdd�Zd�Zdd�Zd�ZRS(swConcrete class that implements an interface to Microsoft Visual C++,
       as defined by the CCompiler abstract class.tmsvcs.cs.ccs.cpps.cxxs.rcs.mcs.ress.objs.libs.dlls%s%ss.exeicCs�tj||||�t�|_t�|_|jdkr�|jdkrjd|_t|j�|_n	d|_d|j|_	nd|jd|_	t
|_dS(NRJisSoftware\Microsoft\VisualStudiosSoftware\Microsoft\DevstudiosVisual Studio version %ssMicrosoft SDK compiler %si(RR'RIt_MSVCCompiler__versionRMt_MSVCCompiler__archt_MSVCCompiler__rootR"t_MSVCCompiler__macrost_MSVCCompiler__producttFalsetinitialized(R%tverbosetdry_runtforce((s./usr/lib64/python2.7/distutils/msvccompiler.pyR'�s		cCs�g|_dtjkrfdtjkrf|jd�rfd|_d|_d|_d|_d|_n�|j	d�|_t
|j�d	kr�td
|j�n|jd�|_|jd�|_|jd�|_|jd�|_|jd�|_|j
d�|j
d�y8x1tjtjdd
�D]}|jj|�q1WWntk
r_nXt|j�|_tj|jd
�tjd<d|_|jdkr�ddddddg|_dddddddg|_n9ddddddg|_dddddddg|_dddg|_|jdkrTddddg|_ndddddg|_dg|_t|_dS( NtDISTUTILS_USE_SDKtMSSdkscl.exeslink.exeslib.exesrc.exesmc.exeR*isxPython was built with %s, and extensions need to be built with the same version of the compiler, but it isn't installed.tlibtincludet;RJs/nologos/Oxs/MDs/W3s/GXs/DNDEBUGs/Ods/MDds/Z7s/D_DEBUGs/GS-s/DLLs/INCREMENTAL:NOis/INCREMENTAL:nos/DEBUGs	/pdb:None(t_MSVCCompiler__pathsRNtenvirontfind_exetcctlinkerRbtrctmctget_msvc_pathsRBRRZtset_path_env_varR9RCRR3RStjoinR
tpreprocess_optionsRWtcompile_optionstcompile_options_debugtldflags_sharedRVtldflags_shared_debugtldflags_statictTrueR\(R%R6((s./usr/lib64/python2.7/distutils/msvccompiler.pyt
initialize�sT	-

tcCs>|dkrd}ng}x|D]}tjj|�\}}tjj|�d}|tjj|�}||jkr�td|��n|r�tjj|�}n||j	kr�|j
tjj|||j��q"||j
kr|j
tjj|||j��q"|j
tjj|||j��q"W|S(NRwisDon't know how to compile %s(R
RNR*tsplitextt
splitdrivetisabstsrc_extensionsRtbasenamet_rc_extensionsRRnt
res_extensiont_mc_extensionst
obj_extension(R%tsource_filenamest	strip_dirt
output_dirt	obj_namestsrc_nameR
text((s./usr/lib64/python2.7/distutils/msvccompiler.pytobject_filenames<s(	
c	Cs�|js|j�n|j||||||�\}}	}}
}|pLg}|jd�|ru|j|j�n|j|j�xM|	D]E}
y||
\}}Wntk
r�q�nX|r�tj	j
|�}n||jkr�d|}n�||jkrd|}nk||j
kr}|}d|
}y)|j|jg|
|g|g�Wq�tk
rv}t|�q�Xq�n�||jkretj	j|�}tj	j|
�}y�|j|jgd|d|g|g�tj	jtj	j|��\}}tj	j||d�}|j|jgd|
g|g�Wq�tk
r^}t|�q�Xq�ntd||
f��d	|
}y-|j|jg||
||g|�Wq�tk
r�}t|�q�Xq�W|	S(
Ns/cs/Tcs/Tps/fos-hs-rs.rcs"Don't know how to compile %s to %ss/Fo(R\Rvt_setup_compileRtextendRqRpR3RNR*tabspatht
_c_extensionst_cpp_extensionsR}tspawnRjRRRtdirnameRkRxR|RnRh(R%tsourcesR�R#tinclude_dirstdebugt
extra_preargstextra_postargstdependstobjectstpp_optstbuildtcompile_optstobjtsrcR�t	input_optt
output_opttmsgth_dirtrc_dirR
t_trc_file((s./usr/lib64/python2.7/distutils/msvccompiler.pytcompile]sj

#
$$#

c	Cs�|js|j�n|j||�\}}|j|d|�}|j||�r�|d|g}|rony|j|jg|�Wq�tk
r�}t|�q�Xnt	j
d|�dS(NR�s/OUT:sskipping %s (up-to-date)(R\Rvt_fix_object_argstlibrary_filenamet
_need_linkR�RbRRRR�(	R%R�toutput_libnameR�R�ttarget_langtoutput_filenametlib_argsR�((s./usr/lib64/python2.7/distutils/msvccompiler.pytcreate_static_lib�s	
cCsW|js|j�n|j||�\}}|j|||�\}}}|rl|jdt|��nt||||�}|dk	r�tj	j
||�}n|j||�rC|tj
kr�|	r�|jd}q|jd}n|	r�|j}n	|j}g}x%|pgD]}|jd|�qW||||d|g}|dk	r�tj	jtj	j|��\}}tj	j
tj	j|d�|j|��}|jd|�n|
r�|
|d*n|r�|j|�n|jtj	j|��y|j|jg|�WqStk
r?}t|�qSXntjd|�dS(Ns5I don't know what to do with 'runtime_library_dirs': is/EXPORT:s/OUT:is/IMPLIB:sskipping %s (up-to-date)(R\RvR�t
_fix_lib_argstwarntstrRR
RNR*RnR�Rt
EXECUTABLERsRrRRxR|R�R�R�tmkpathR�RiRRRR�(R%ttarget_descR�R�R�t	librariestlibrary_dirstruntime_library_dirstexport_symbolsR�R�R�t
build_tempR�tlib_optstldflagstexport_optstsymtld_argstdll_nametdll_exttimplib_fileR�((s./usr/lib64/python2.7/distutils/msvccompiler.pytlink�sR	
					
cCsd|S(Ns	/LIBPATH:((R%tdir((s./usr/lib64/python2.7/distutils/msvccompiler.pytlibrary_dir_option$scCs
td�dS(Ns<don't know how to set runtime library search path for MSVC++(R(R%R�((s./usr/lib64/python2.7/distutils/msvccompiler.pytruntime_library_dir_option'scCs
|j|�S(N(R�(R%Rb((s./usr/lib64/python2.7/distutils/msvccompiler.pytlibrary_option+scCs�|r|d|g}n	|g}xW|D]K}xB|D]:}tjj||j|��}tjj|�r6|Sq6Wq)WdSdS(Nt_d(RNR*RnR�texistsR
(R%tdirsRbR�t	try_namesR�Rtlibfile((s./usr/lib64/python2.7/distutils/msvccompiler.pytfind_library_file/s

cCs�xH|jD]=}tjjtjj|�|�}tjj|�r
|Sq
WxXtjtjdd�D]=}tjjtjj|�|�}tjj|�re|SqeW|S(s�Return path to an MSVC executable program.

Return a list of strings.  The list will be empty if unable to
        access the registry or appropriate registry keys not found.
        s dirsis6%s\%0.1f\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directoriess?%s\6.0\Build System\Components\Platforms\Win32 (%s)\DirectoriesRdis%s\6.0s�It seems you have Visual Studio 6 installed, but the expected registry settings are not present.
You must at least run the Visual Studio GUI once so that these entries are created.N(t
_can_read_regRVRXR(RR9RCRYR<R
R�(R%R*tplatformRR
R((s./usr/lib64/python2.7/distutils/msvccompiler.pyRlZs(

cCsS|dkr|jd�}n|j|�}|rOtj|d�tj|<ndS(s�Set environment variable 'name' to an MSVC path type value.

This is equivalent to a SET command prior to execution of spawned
        commands.
        RbtlibraryRdN(RlR9RnRNRf(R%RR6((s./usr/lib64/python2.7/distutils/msvccompiler.pyRms
N(R=R>t__doc__t
compiler_typetexecutablesR�R�R}RR{R~R�tstatic_lib_extensiontshared_lib_extensiontstatic_lib_formattshared_lib_formatt
exe_extensionR'RvR�R
R�R�R�R�R�R�R�RgRlRm(((s./usr/lib64/python2.7/distutils/msvccompiler.pyRT�sP			
	BZG				%g @s3Importing new compiler from distutils.msvc9compiler(RT(R"(/R�t__revision__RARNR9tdistutils.errorsRRRRRtdistutils.ccompilerRRt	distutilsRR�t_winregthkey_modt	OpenKeyExRtEnumKeyRt	EnumValueRterrorR	tImportErrortwin32apitwin32continfot
HKEY_USERStHKEY_CURRENT_USERtHKEY_LOCAL_MACHINEtHKEY_CLASSES_ROOTR(RRRR"RIRMRSRTR�tOldMSVCCompilertdistutils.msvc9compiler(((s./usr/lib64/python2.7/distutils/msvccompiler.pyt<module>s`(

.		
	��
spawn.pyc000064400000014433151702014350006414 0ustar00�
{fc@s�dZdZddlZddlZddlmZmZddlmZddl	m
Z
dddd	�Zd
�Zdddd�Z
dddd�Zejd
kr�ddl	mZdadandddd�Zdd�ZdS(s�distutils.spawn

Provides the 'spawn()' function, a front-end to various platform-
specific functions for launching another program in a sub-process.
Also provides the 'find_executable()' to search the path for a given
executable name.
s$Id$i����N(tDistutilsPlatformErrortDistutilsExecError(tDEBUG(tlogiicCs�t|�}tjdkr1t||d|�nZtjdkrVt||d|�n5tjdkr{t||d|�ntdtj�dS(s�Run another program, specified as a command list 'cmd', in a new process.

'cmd' is just the argument list for the new process, ie.
    cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
    There is no way to run a program with a name different from that of its
    executable.

If 'search_path' is true (the default), the system's executable
    search path will be used to find the program; otherwise, cmd[0]
    must be the exact path to the executable.  If 'dry_run' is true,
    the command will not actually be run.

Raise DistutilsExecError if running the program fails in any way; just
    return on success.
    tposixtdry_runtnttos2s1don't know how to spawn programs on platform '%s'N(tlisttostnamet_spawn_posixt	_spawn_ntt
_spawn_os2R(tcmdtsearch_pathtverboseR((s'/usr/lib64/python2.7/distutils/spawn.pytspawnscCs>x7t|�D])\}}d|kr
d|||<q
q
W|S(s�Quote command-line arguments for DOS/Windows conventions.

Just wraps every argument which contains blanks in double quotes, and
    returns a new argument list.
    t s"%s"(t	enumerate(targstitarg((s'/usr/lib64/python2.7/distutils/spawn.pyt_nt_quote_args/scCs�|d}t|�}|r1t|�p+|}ntjdj|g|d��|s�ytjtj||�}Wn9tk
r�}t	s�|}nt
d||df�nX|dkr�t	s�|}nt
d||f�q�ndS(NiRiscommand %r failed: %si����s%command %r failed with exit status %d(Rtfind_executableRtinfotjoinR	tspawnvtP_WAITtOSErrorRR(RRRRt
executabletrctexc((s'/usr/lib64/python2.7/distutils/spawn.pyR?s$
!		cCs�|d}|r%t|�p|}ntjdj|g|d��|s�ytjtj||�}Wn9tk
r�}ts�|}nt	d||df�nX|dkr�ts�|}ntj
d||f�t	d||f�q�ndS(NiRiscommand %r failed: %si����s%command %r failed with exit status %d(RRRRR	RRRRRtdebug(RRRRRRR ((s'/usr/lib64/python2.7/distutils/spawn.pyR
Ws$
!		tdarwin(t	sysconfigcCs_tjdj|��|r dS|d}|r9tjp?tj}d}tjdkrGt	dkr�t
jd�puda	t	r�gt	jd�D]}t
|�^q�aq�nt	rGtjjdt	�}tg|jd�D]}t
|�^q�krd|t	f}	t|	��nttjd|�}|r8tjp>tj}qGntj�}
|
dkry0|dkr~|||�n||||�WnLtk
r�}ts�|}ntjjd||jf�tjd	�nXts�|}ntjjd
|�tjd	�nJxGytj|
d�\}
}Wn]tk
r�}
ddl}|
j|jkrfqntsu|}ntd||
df�nXtj |�r�ts�|}ntd
|tj!|�f�qtj"|�r tj#|�}|dkr�dSts
|}ntd||f�qtj$|�r5qqtsD|}ntd||f�qWdS(NRiR"tMACOSX_DEPLOYMENT_TARGETtt.sF$MACOSX_DEPLOYMENT_TARGET mismatch: now "%s" but "%s" during configuresunable to execute %r: %s
is(unable to execute %r for unknown reasonsi����scommand %r failed: %ss"command %r terminated by signal %ds%command %r failed with exit status %ds1unknown error executing %r: termination status %d(%RRRR	texecvptexecvtNonetsystplatformt_cfg_targetR#tget_config_vartsplittintt_cfg_target_splittenvirontgetRtdicttexecvpetexecvetforkRRtstderrtwritetstrerrort_exittwaitpidterrnotEINTRRtWIFSIGNALEDtWTERMSIGt	WIFEXITEDtWEXITSTATUSt
WIFSTOPPED(RRRRRtexec_fntenvtxt
cur_targettmy_msgtpidtetstatusR R<texit_status((s'/usr/lib64/python2.7/distutils/spawn.pyRts�
..
							cCs�|dkr'tjjdtj�}n|jtj�}tjj|�\}}t	j
dksotjdkr�|dkr�|d}ntjj|�s�x9|D]1}tjj
||�}tjj|�r�|Sq�WdS|SdS(s�Tries to find 'executable' in the directories listed in 'path'.

A string listing directories separated by 'os.pathsep'; defaults to
    os.environ['PATH'].  Returns the complete filename or None if not found.
    tPATHtwin32Rs.exeN(R)R	R1R2tdefpathR.tpathseptpathtsplitextR*R+R
tisfileR(RRPtpathstbasetexttptf((s'/usr/lib64/python2.7/distutils/spawn.pyR�s*

(t__doc__t__revision__R*R	tdistutils.errorsRRtdistutils.debugRt	distutilsRRRRR
R+R#R)R,R0RR(((s'/usr/lib64/python2.7/distutils/spawn.pyt<module>s 		Xsysconfig.py.debug-build000064400000042326151702014350011311 0ustar00"""Provide access to Python's configuration information.  The specific
configuration variables available depend heavily on the platform and
configuration.  The values may be retrieved using
get_config_var(name), and the list of variables is available via
get_config_vars().keys().  Additional convenience functions are also
available.

Written by:   Fred L. Drake, Jr.
Email:        <fdrake@acm.org>
"""

__revision__ = "$Id$"

import os
import re
import string
import sys

from distutils.errors import DistutilsPlatformError

# These are needed in a couple of spots, so just compute them once.
PREFIX = os.path.normpath(sys.prefix)
EXEC_PREFIX = os.path.normpath(sys.exec_prefix)

# Path to the base directory of the project. On Windows the binary may
# live in project/PCBuild9.  If we're dealing with an x64 Windows build,
# it'll live in project/PCbuild/amd64.
if sys.executable:
    project_base = os.path.dirname(os.path.abspath(sys.executable))
else:
    # sys.executable can be empty if argv[0] has been changed and Python is
    # unable to retrieve the real program name
    project_base = os.getcwd()
if os.name == "nt" and "pcbuild" in project_base[-8:].lower():
    project_base = os.path.abspath(os.path.join(project_base, os.path.pardir))
# PC/VS7.1
if os.name == "nt" and "\\pc\\v" in project_base[-10:].lower():
    project_base = os.path.abspath(os.path.join(project_base, os.path.pardir,
                                                os.path.pardir))
# PC/AMD64
if os.name == "nt" and "\\pcbuild\\amd64" in project_base[-14:].lower():
    project_base = os.path.abspath(os.path.join(project_base, os.path.pardir,
                                                os.path.pardir))

# set for cross builds
if "_PYTHON_PROJECT_BASE" in os.environ:
    # this is the build directory, at least for posix
    project_base = os.path.normpath(os.environ["_PYTHON_PROJECT_BASE"])

# python_build: (Boolean) if true, we're either building Python or
# building an extension with an un-installed Python, so we use
# different (hard-wired) directories.
# Setup.local is available for Makefile builds including VPATH builds,
# Setup.dist is available on Windows
def _python_build():
    for fn in ("Setup.dist", "Setup.local"):
        if os.path.isfile(os.path.join(project_base, "Modules", fn)):
            return True
    return False
python_build = _python_build()

def get_python_version():
    """Return a string containing the major and minor Python version,
    leaving off the patchlevel.  Sample return values could be '1.5'
    or '2.2'.
    """
    return sys.version[:3]

def get_python_inc(plat_specific=0, prefix=None):
    """Return the directory containing installed Python header files.

If 'plat_specific' is false (the default), this is the path to the
    non-platform-specific header files, i.e. Python.h and so on;
    otherwise, this is the path to platform-specific header files
    (namely pyconfig.h).

If 'prefix' is supplied, use it instead of sys.prefix or
    sys.exec_prefix -- i.e., ignore 'plat_specific'.
    """
    if prefix is None:
        prefix = plat_specific and EXEC_PREFIX or PREFIX

if os.name == "posix":
        if python_build:
            if sys.executable:
                buildir = os.path.dirname(sys.executable)
            else:
                # sys.executable can be empty if argv[0] has been changed
                # and Python is unable to retrieve the real program name
                buildir = os.getcwd()
            if plat_specific:
                # python.h is located in the buildir
                inc_dir = buildir
            else:
                # the source dir is relative to the buildir
                srcdir = os.path.abspath(os.path.join(buildir,
                                         get_config_var('srcdir')))
                # Include is located in the srcdir
                inc_dir = os.path.join(srcdir, "Include")
            return inc_dir
        return os.path.join(prefix, "include", "python" + get_python_version())
    elif os.name == "nt":
        return os.path.join(prefix, "include")
    elif os.name == "os2":
        return os.path.join(prefix, "Include")
    else:
        raise DistutilsPlatformError(
            "I don't know where Python installs its C header files "
            "on platform '%s'" % os.name)

def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
    """Return the directory containing the Python library (standard or
    site additions).

If 'plat_specific' is true, return the directory containing
    platform-specific modules, i.e. any module from a non-pure-Python
    module distribution; otherwise, return the platform-shared library
    directory.  If 'standard_lib' is true, return the directory
    containing standard Python library modules; otherwise, return the
    directory for site-specific modules.

If 'prefix' is supplied, use it instead of sys.prefix or
    sys.exec_prefix -- i.e., ignore 'plat_specific'.
    """
    if prefix is None:
        prefix = plat_specific and EXEC_PREFIX or PREFIX

if os.name == "posix":
        if plat_specific or standard_lib:
            lib = "lib64"
        else:
            lib = "lib"
        libpython = os.path.join(prefix,
                                 lib, "python" + get_python_version())
        if standard_lib:
            return libpython
        else:
            return os.path.join(libpython, "site-packages")

elif os.name == "nt":
        if standard_lib:
            return os.path.join(prefix, "Lib")
        else:
            if get_python_version() < "2.2":
                return prefix
            else:
                return os.path.join(prefix, "Lib", "site-packages")

elif os.name == "os2":
        if standard_lib:
            return os.path.join(prefix, "Lib")
        else:
            return os.path.join(prefix, "Lib", "site-packages")

else:
        raise DistutilsPlatformError(
            "I don't know where Python installs its library "
            "on platform '%s'" % os.name)

def customize_compiler(compiler):
    """Do any platform-specific customization of a CCompiler instance.

Mainly needed on Unix, so we can plug in the information that
    varies across Unices and is stored in Python's Makefile.
    """
    if compiler.compiler_type == "unix":
        if sys.platform == "darwin":
            # Perform first-time customization of compiler-related
            # config vars on OS X now that we know we need a compiler.
            # This is primarily to support Pythons from binary
            # installers.  The kind and paths to build tools on
            # the user system may vary significantly from the system
            # that Python itself was built on.  Also the user OS
            # version and build tools may not support the same set
            # of CPU architectures for universal builds.
            global _config_vars
            # Use get_config_var() to ensure _config_vars is initialized.
            if not get_config_var('CUSTOMIZED_OSX_COMPILER'):
                import _osx_support
                _osx_support.customize_compiler(_config_vars)
                _config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'

(cc, cxx, cflags, ccshared, ldshared, so_ext, ar, ar_flags) = \
            get_config_vars('CC', 'CXX', 'CFLAGS',
                            'CCSHARED', 'LDSHARED', 'SO', 'AR',
                            'ARFLAGS')

if 'CC' in os.environ:
            newcc = os.environ['CC']
            if (sys.platform == 'darwin'
                    and 'LDSHARED' not in os.environ
                    and ldshared.startswith(cc)):
                # On OS X, if CC is overridden, use that as the default
                #       command for LDSHARED as well
                ldshared = newcc + ldshared[len(cc):]
            cc = newcc
        if 'CXX' in os.environ:
            cxx = os.environ['CXX']
        if 'LDSHARED' in os.environ:
            ldshared = os.environ['LDSHARED']
        if 'CPP' in os.environ:
            cpp = os.environ['CPP']
        else:
            cpp = cc + " -E"           # not always
        if 'LDFLAGS' in os.environ:
            ldshared = ldshared + ' ' + os.environ['LDFLAGS']
        if 'CFLAGS' in os.environ:
            cflags = cflags + ' ' + os.environ['CFLAGS']
            ldshared = ldshared + ' ' + os.environ['CFLAGS']
        if 'CPPFLAGS' in os.environ:
            cpp = cpp + ' ' + os.environ['CPPFLAGS']
            cflags = cflags + ' ' + os.environ['CPPFLAGS']
            ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
        if 'AR' in os.environ:
            ar = os.environ['AR']
        if 'ARFLAGS' in os.environ:
            archiver = ar + ' ' + os.environ['ARFLAGS']
        else:
            archiver = ar + ' ' + ar_flags

cc_cmd = cc + ' ' + cflags
        compiler.set_executables(
            preprocessor=cpp,
            compiler=cc_cmd,
            compiler_so=cc_cmd + ' ' + ccshared,
            compiler_cxx=cxx,
            linker_so=ldshared,
            linker_exe=cc,
            archiver=archiver)

compiler.shared_lib_extension = so_ext

def get_config_h_filename():
    """Return full pathname of installed pyconfig.h file."""
    if python_build:
        if os.name == "nt":
            inc_dir = os.path.join(project_base, "PC")
        else:
            inc_dir = project_base
    else:
        inc_dir = get_python_inc(plat_specific=1)
    if get_python_version() < '2.2':
        config_h = 'config.h'
    else:
        # The name of the config.h file changed in 2.2
        config_h = 'pyconfig.h'
    return os.path.join(inc_dir, config_h)

def get_makefile_filename():
    """Return full pathname of installed Makefile from the Python build."""
    if python_build:
        return os.path.join(project_base, "Makefile")
    lib_dir = get_python_lib(plat_specific=1, standard_lib=1)
    return os.path.join(lib_dir, "config", "Makefile")

def parse_config_h(fp, g=None):
    """Parse a config.h-style file.

A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    """
    if g is None:
        g = {}
    define_rx = re.compile("#define ([A-Z][A-Za-z0-9_]+) (.*)\n")
    undef_rx = re.compile("/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/\n")
    #
    while 1:
        line = fp.readline()
        if not line:
            break
        m = define_rx.match(line)
        if m:
            n, v = m.group(1, 2)
            try: v = int(v)
            except ValueError: pass
            g[n] = v
        else:
            m = undef_rx.match(line)
            if m:
                g[m.group(1)] = 0
    return g

# Regexes needed for parsing Makefile (and similar syntaxes,
# like old-style Setup files).
_variable_rx = re.compile("([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
_findvar1_rx = re.compile(r"\$$([A-Za-z][A-Za-z0-9_]*)$")
_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")

def parse_makefile(fn, g=None):
    """Parse a Makefile-style file.

A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    """
    from distutils.text_file import TextFile
    fp = TextFile(fn, strip_comments=1, skip_blanks=1, join_lines=1)

if g is None:
        g = {}
    done = {}
    notdone = {}

while 1:
        line = fp.readline()
        if line is None:  # eof
            break
        m = _variable_rx.match(line)
        if m:
            n, v = m.group(1, 2)
            v = v.strip()
            # `$$' is a literal `$' in make
            tmpv = v.replace('$$', '')

if "$" in tmpv:
                notdone[n] = v
            else:
                try:
                    v = int(v)
                except ValueError:
                    # insert literal `$'
                    done[n] = v.replace('$$', '$')
                else:
                    done[n] = v

# do variable interpolation here
    while notdone:
        for name in notdone.keys():
            value = notdone[name]
            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
            if m:
                n = m.group(1)
                found = True
                if n in done:
                    item = str(done[n])
                elif n in notdone:
                    # get it on a subsequent round
                    found = False
                elif n in os.environ:
                    # do it like make: fall back to environment
                    item = os.environ[n]
                else:
                    done[n] = item = ""
                if found:
                    after = value[m.end():]
                    value = value[:m.start()] + item + after
                    if "$" in after:
                        notdone[name] = value
                    else:
                        try: value = int(value)
                        except ValueError:
                            done[name] = value.strip()
                        else:
                            done[name] = value
                        del notdone[name]
            else:
                # bogus variable reference; just drop it since we can't deal
                del notdone[name]

fp.close()

# strip spurious spaces
    for k, v in done.items():
        if isinstance(v, str):
            done[k] = v.strip()

# save the results in the global dictionary
    g.update(done)
    return g

def expand_makefile_vars(s, vars):
    """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
    'string' according to 'vars' (a dictionary mapping variable names to
    values).  Variables not present in 'vars' are silently expanded to the
    empty string.  The variable values in 'vars' should not contain further
    variable expansions; if 'vars' is the output of 'parse_makefile()',
    you're fine.  Returns a variable-expanded version of 's'.
    """

# This algorithm does multiple expansion, so if vars['foo'] contains
    # "${bar}", it will expand ${foo} to ${bar}, and then expand
    # ${bar}... and so forth.  This is fine as long as 'vars' comes from
    # 'parse_makefile()', which takes care of such expansions eagerly,
    # according to make's variable expansion semantics.

while 1:
        m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
        if m:
            (beg, end) = m.span()
            s = s[0:beg] + vars.get(m.group(1)) + s[end:]
        else:
            break
    return s

_config_vars = None

def _init_posix():
    """Initialize the module as appropriate for POSIX systems."""
    # _sysconfigdata is generated at build time, see the sysconfig module
    from _sysconfigdata import build_time_vars
    global _config_vars
    _config_vars = {}
    _config_vars.update(build_time_vars)

def _init_nt():
    """Initialize the module as appropriate for NT"""
    g = {}
    # set basic install directories
    g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
    g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)

# XXX hmmm.. a normal install puts include files here
    g['INCLUDEPY'] = get_python_inc(plat_specific=0)

g['SO'] = '.pyd'
    g['EXE'] = ".exe"
    g['VERSION'] = get_python_version().replace(".", "")
    g['BINDIR'] = os.path.dirname(os.path.abspath(sys.executable))

global _config_vars
    _config_vars = g

def _init_os2():
    """Initialize the module as appropriate for OS/2"""
    g = {}
    # set basic install directories
    g['LIBDEST'] = get_python_lib(plat_specific=0, standard_lib=1)
    g['BINLIBDEST'] = get_python_lib(plat_specific=1, standard_lib=1)

# XXX hmmm.. a normal install puts include files here
    g['INCLUDEPY'] = get_python_inc(plat_specific=0)

g['SO'] = '.pyd'
    g['EXE'] = ".exe"

global _config_vars
    _config_vars = g

def get_config_vars(*args):
    """With no arguments, return a dictionary of all configuration
    variables relevant for the current platform.  Generally this includes
    everything needed to build extensions and install both pure modules and
    extensions.  On Unix, this means every variable defined in Python's
    installed Makefile; on Windows and Mac OS it's a much smaller set.

With arguments, return a list of values that result from looking up
    each argument in the configuration variable dictionary.
    """
    global _config_vars
    if _config_vars is None:
        func = globals().get("_init_" + os.name)
        if func:
            func()
        else:
            _config_vars = {}

# Normalized versions of prefix and exec_prefix are handy to have;
        # in fact, these are the standard versions used most places in the
        # Distutils.
        _config_vars['prefix'] = PREFIX
        _config_vars['exec_prefix'] = EXEC_PREFIX

# OS X platforms require special customization to handle
        # multi-architecture, multi-os-version installers
        if sys.platform == 'darwin':
            import _osx_support
            _osx_support.customize_config_vars(_config_vars)

if args:
        vals = []
        for name in args:
            vals.append(_config_vars.get(name))
        return vals
    else:
        return _config_vars

def get_config_var(name):
    """Return the value of a single variable using the dictionary
    returned by 'get_config_vars()'.  Equivalent to
    get_config_vars().get(name)
    """
    return get_config_vars().get(name)
sysconfig.pyc000064400000032134151702014350007266 0ustar00�
�fc@s�dZdZddlZddlZddlZddlZddlmZejj	ej
�Zejj	ej�Z
ejr�ejjejjej��Znej�Zejdkr�dedj�kr�ejjejjeejj��ZnejdkrVded	j�krVejjejjeejjejj��Znejdkr�d
edj�kr�ejjejjeejjejj��Zndejkr�ejj	ejd�Znd
�Ze�Zd�Zddd�Zdddd�Zd�Zd�Zd�Z dd�Z!ej"d�Z#ej"d�Z$ej"d�Z%dd�Z&d�Z'da(d�Z)d�Z*d�Z+d�Z,d�Z-dS( s�Provide access to Python's configuration information.  The specific
configuration variables available depend heavily on the platform and
configuration.  The values may be retrieved using
get_config_var(name), and the list of variables is available via
get_config_vars().keys().  Additional convenience functions are also
available.

Written by:   Fred L. Drake, Jr.
Email:        <fdrake@acm.org>
s$Id$i����N(tDistutilsPlatformErrortnttpcbuildi����s\pc\vi����s\pcbuild\amd64i�t_PYTHON_PROJECT_BASEcCs=x6dD].}tjjtjjtd|��rtSqWtS(Ns
Setup.distsSetup.localtModules(s
Setup.distsSetup.local(tostpathtisfiletjointproject_basetTruetFalse(tfn((s+/usr/lib64/python2.7/distutils/sysconfig.pyt
_python_build7s
$cCstjd S(s�Return a string containing the major and minor Python version,
    leaving off the patchlevel.  Sample return values could be '1.5'
    or '2.2'.
    i(tsystversion(((s+/usr/lib64/python2.7/distutils/sysconfig.pytget_python_version?sicCs=|dkr!|rtpt}ntjdkr�tr�tjrWtjj	tj�}ntj
�}|rr|}n<tjjtjj|t
d���}tjj|d�}|Stjj|ddt�tjr�dp�d�Stjdkrtjj|d�Stjd	kr&tjj|d�Std
tj��dS(s�Return the directory containing installed Python header files.

If 'prefix' is supplied, use it instead of sys.prefix or
    sys.exec_prefix -- i.e., ignore 'plat_specific'.
    tposixtsrcdirtIncludetincludetpythons-debugtRtos2sFI don't know where Python installs its C header files on platform '%s'N(tNonetEXEC_PREFIXtPREFIXRtnametpython_buildRt
executableRtdirnametgetcwdtabspathRtget_config_varRtpydebugR(t
plat_specifictprefixtbuildirtinc_dirR((s+/usr/lib64/python2.7/distutils/sysconfig.pytget_python_incGs,		!cCs6|dkr!|rtpt}ntjdkr�|s<|rEd}nd}tjj||dt��}|rt|Stjj|d�Sn�tjdkr�|r�tjj|d�St�dkr�|Stjj|dd�SnTtjd	kr|rtjj|d�Stjj|dd�Sntd
tj��dS(sIReturn the directory containing the Python library (standard or
    site additions).

If 'prefix' is supplied, use it instead of sys.prefix or
    sys.exec_prefix -- i.e., ignore 'plat_specific'.
    Rtlib64tlibRs
site-packagesRtLibs2.2Rs?I don't know where Python installs its library on platform '%s'N(	RRRRRRRRR(R#tstandard_libR$R)t	libpython((s+/usr/lib64/python2.7/distutils/sysconfig.pytget_python_libss0	cCs�|jdkr�tjdkrStd�sSddl}|jt�dtd<qSntddd	d
ddd
d�\}}}}}}}}	dtj	kr�tj	d}
tjdkr�dtj	kr�|j
|�r�|
|t|�}n|
}ndtj	krtj	d}ndtj	kr3tj	d}ndtj	krRtj	d}n
|d}dtj	kr�|dtj	d}nd	tj	kr�|dtj	d	}|dtj	d	}ndtj	kr|dtj	d}|dtj	d}|dtj	d}nd
tj	kr/tj	d
}ndtj	krV|dtj	d}n|d|	}|d|}
|jd|d|
d|
d|d|d|d|d|�||_
ndS(s�Do any platform-specific customization of a CCompiler instance.

Mainly needed on Unix, so we can plug in the information that
    varies across Unices and is stored in Python's Makefile.
    tunixtdarwintCUSTOMIZED_OSX_COMPILERi����NR
tCCtCXXtCFLAGStCCSHAREDtLDSHAREDtSOtARtARFLAGStCPPs -EtLDFLAGSt tCPPFLAGStpreprocessortcompilertcompiler_sotcompiler_cxxt	linker_sot
linker_exetarchiver(t
compiler_typeRtplatformR!t_osx_supporttcustomize_compilert_config_varstget_config_varsRtenviront
startswithtlentset_executablestshared_lib_extension(R>RFtcctcxxtcflagstccsharedtldsharedtso_exttartar_flagstnewcctcppRCtcc_cmd((s+/usr/lib64/python2.7/distutils/sysconfig.pyRG�s^
!
	
	cCsvtr6tjdkr-tjjtd�}qEt}ntdd�}t�dkr]d}nd}tjj||�S(s2Return full pathname of installed pyconfig.h file.RtPCR#is2.2sconfig.hs
pyconfig-64.h(RRRRRR	R'R(R&tconfig_h((s+/usr/lib64/python2.7/distutils/sysconfig.pytget_config_h_filename�s		cCsWtrtjjtd�Stdddd�}tjj|dtjrLdpOdd�S(sAReturn full pathname of installed Makefile from the Python build.tMakefileR#iR+tconfigs-debugR(RRRRR	R-RR"(tlib_dir((s+/usr/lib64/python2.7/distutils/sysconfig.pytget_makefile_filenamescCs�|dkri}ntjd�}tjd�}x�|j�}|sLPn|j|�}|r�|jdd�\}}yt|�}Wntk
r�nX|||<q6|j|�}|r6d||jd�<q6q6W|S(s�Parse a config.h-style file.

A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    s"#define ([A-Z][A-Za-z0-9_]+) (.*)
s&/[*] #undef ([A-Z][A-Za-z0-9_]+) [*]/
iiiN(Rtretcompiletreadlinetmatchtgrouptintt
ValueError(tfptgt	define_rxtundef_rxtlinetmtntv((s+/usr/lib64/python2.7/distutils/sysconfig.pytparse_config_h	s(

s"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)s\$$([A-Za-z][A-Za-z0-9_]*)$s\${([A-Za-z][A-Za-z0-9_]*)}cCs�ddlm}||dddddd�}|dkrCi}ni}i}x�|j�}|dkrnPntj|�}|rR|jdd�\}}	|	j�}	|	jdd	�}
d
|
kr�|	||<qyt	|	�}	Wn't
k
r|	jdd
�||<qX|	||<qRqRWx^|r}xQ|j�D]C}||}tj
|�p^tj
|�}|ro|jd�}t}
||kr�t||�}nB||kr�t}
n-|tjkr�tj|}nd	||<}|
rv||j�}||j� ||}d
|kr$|||<qlyt	|�}Wn!t
k
rW|j�||<nX|||<||=qvq3||=q3Wq W|j�x<|j�D].\}}	t|	t�r�|	j�||<q�q�W|j|�|S(s�Parse a Makefile-style file.

A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    i����(tTextFiletstrip_commentsitskip_blankst
join_linesis$$Rt$N(tdistutils.text_fileRqRRct_variable_rxRdRetstriptreplaceRfRgtkeyst_findvar1_rxtsearcht_findvar2_rxR
tstrRRRJtendtstarttclosetitemst
isinstancetupdate(RRiRqRhtdonetnotdoneRlRmRnRottmpvRtvaluetfoundtitemtaftertk((s+/usr/lib64/python2.7/distutils/sysconfig.pytparse_makefile,sl

cCspxitj|�ptj|�}|rg|j�\}}|d|!|j|jd��||}qPqW|S(s�Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
    'string' according to 'vars' (a dictionary mapping variable names to
    values).  Variables not present in 'vars' are silently expanded to the
    empty string.  The variable values in 'vars' should not contain further
    variable expansions; if 'vars' is the output of 'parse_makefile()',
    you're fine.  Returns a variable-expanded version of 's'.
    ii(R{R|R}tspantgetRe(tstvarsRmtbegR((s+/usr/lib64/python2.7/distutils/sysconfig.pytexpand_makefile_varss.cCs'ddlm}iatj|�dS(s7Initialize the module as appropriate for POSIX systems.i����(tbuild_time_varsN(t_sysconfigdataR�RHR�(R�((s+/usr/lib64/python2.7/distutils/sysconfig.pyt_init_posix�scCs�i}tdddd�|d<tdddd�|d<tdd�|d<d|d	<d
|d<t�jdd
�|d<tjjtjjtj	��|d<|a
dS(s+Initialize the module as appropriate for NTR#iR+itLIBDESTt
BINLIBDESTt	INCLUDEPYs.pydR6s.exetEXEt.RtVERSIONtBINDIRN(R-R'RRyRRRR RRRH(Ri((s+/usr/lib64/python2.7/distutils/sysconfig.pyt_init_nt�s

%cCsii}tdddd�|d<tdddd�|d<tdd�|d<d|d	<d
|d<|adS(
s-Initialize the module as appropriate for OS/2R#iR+iR�R�R�s.pydR6s.exeR�N(R-R'RH(Ri((s+/usr/lib64/python2.7/distutils/sysconfig.pyt	_init_os2�s

cGs�tdkr}t�jdtj�}|r5|�niattd<ttd<tj	dkr}ddl
}|jt�q}n|r�g}x$|D]}|jtj|��q�W|StSdS(s�With no arguments, return a dictionary of all configuration
    variables relevant for the current platform.  Generally this includes
    everything needed to build extensions and install both pure modules and
    extensions.  On Unix, this means every variable defined in Python's
    installed Makefile; on Windows and Mac OS it's a much smaller set.

With arguments, return a list of values that result from looking up
    each argument in the configuration variable dictionary.
    t_init_R$texec_prefixR/i����N(
RHRtglobalsR�RRRRRRERFtcustomize_config_varstappend(targstfuncRFtvalsR((s+/usr/lib64/python2.7/distutils/sysconfig.pyRI�s

cCst�j|�S(s�Return the value of a single variable using the dictionary
    returned by 'get_config_vars()'.  Equivalent to
    get_config_vars().get(name)
    (RIR�(R((s+/usr/lib64/python2.7/distutils/sysconfig.pyR!�s(.t__doc__t__revision__RRatstringRtdistutils.errorsRRtnormpathR$RR�RRRR R	RRtlowerRtpardirRJR
RRRR'R-RGR\R`RpRbRwR{R}R�R�RHR�R�R�RIR!(((s+/usr/lib64/python2.7/distutils/sysconfig.pyt<module>
sR	$%*%%			,3	J		S						&text_file.pyc000064400000022053151702014350007244 0ustar00�
{fc@s/dZdZddlZddd��YZdS(s�text_file

provides the TextFile class, which gives an interface to text files
that (optionally) takes care of stripping comments, ignoring blank
lines, and joining lines with backslashes.s$Id$i����NtTextFilecBs�eZdZidd6dd6dd6dd6dd6dd6Zddd	�Zd
�Zd�Zdd�Zdd
�Z	dd�Z
d�Zd�Zd�Z
RS(s�Provides a file-like object that takes care of all the things you
       commonly want to do when processing a text file that has some
       line-by-line syntax: strip comments (as long as "#" is your
       comment character), skip blank lines, join adjacent lines by
       escaping the newline (ie. backslash at end of line), strip
       leading and/or trailing whitespace.  All of these are optional
       and independently controllable.

Provides a 'warn()' method so you can generate warning messages that
       report physical line number, even if the logical line in question
       spans multiple physical lines.  Also provides 'unreadline()' for
       implementing line-at-a-time lookahead.

Constructor is called as:

TextFile (filename=None, file=None, **options)

It bombs (RuntimeError) if both 'filename' and 'file' are None;
       'filename' should be a string, and 'file' a file object (or
       something that provides 'readline()' and 'close()' methods).  It is
       recommended that you supply at least 'filename', so that TextFile
       can include it in warning messages.  If 'file' is not supplied,
       TextFile creates its own using the 'open()' builtin.

The options are all boolean, and affect the value returned by
       'readline()':
         strip_comments [default: true]
           strip from "#" to end-of-line, as well as any whitespace
           leading up to the "#" -- unless it is escaped by a backslash
         lstrip_ws [default: false]
           strip leading whitespace from each line before returning it
         rstrip_ws [default: true]
           strip trailing whitespace (including line terminator!) from
           each line before returning it
         skip_blanks [default: true}
           skip lines that are empty *after* stripping comments and
           whitespace.  (If both lstrip_ws and rstrip_ws are false,
           then some lines may consist of solely whitespace: these will
           *not* be skipped, even if 'skip_blanks' is true.)
         join_lines [default: false]
           if a backslash is the last non-newline character on a line
           after stripping comments and whitespace, join the following line
           to it to form one "logical line"; if N consecutive lines end
           with a backslash, then N+1 physical lines will be joined to
           form one logical line.
         collapse_join [default: false]
           strip leading whitespace from lines that are joined to their
           predecessor; only matters if (join_lines and not lstrip_ws)

Note that since 'rstrip_ws' can strip the trailing newline, the
       semantics of 'readline()' must differ from those of the builtin file
       object's 'readline()' method!  In particular, 'readline()' returns
       None for end-of-file: an empty string might just be a blank line (or
       an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
       not.itstrip_commentstskip_blanksit	lstrip_wst	rstrip_wst
join_linest
collapse_joincKs�|dkr$|dkr$td�nxQ|jj�D]@}||kr]t||||�q4t|||j|�q4Wx3|j�D]%}||jkr�td|�q�q�W|dkr�|j|�n||_||_d|_	g|_
dS(s�Construct a new TextFile object.  At least one of 'filename'
           (a string) and 'file' (a file-like object) must be supplied.
           They keyword argument options are described above and affect
           the values returned by 'readline()'.s7you must supply either or both of 'filename' and 'file'sinvalid TextFile option '%s'iN(tNonetRuntimeErrortdefault_optionstkeystsetattrtKeyErrortopentfilenametfiletcurrent_linetlinebuf(tselfRRtoptionstopt((s+/usr/lib64/python2.7/distutils/text_file.pyt__init__Ns 				cCs+||_t|jd�|_d|_dS(syOpen a new file named 'filename'.  This overrides both the
           'filename' and 'file' arguments to the constructor.triN(RR
RR(RR((s+/usr/lib64/python2.7/distutils/text_file.pyR
ss	cCs2|j}d|_d|_d|_|j�dS(siClose the current file and forget everything we know about it
           (filename, current line number).N(RRRRtclose(RR((s+/usr/lib64/python2.7/distutils/text_file.pyR|s
				cCs�g}|dkr|j}n|j|jd�t|ttf�ra|jdt|��n|jd|�|jt|��dj|�S(Ns, s
lines %d-%d: s	line %d: t(	RRtappendRt
isinstancetlistttupletstrtjoin(Rtmsgtlinetoutmsg((s+/usr/lib64/python2.7/distutils/text_file.pyt	gen_error�scCstd|j||��dS(Nserror: (t
ValueErrorR"(RRR ((s+/usr/lib64/python2.7/distutils/text_file.pyterror�scCs(tjjd|j||�d�dS(s�Print (to stderr) a warning message tied to the current logical
           line in the current file.  If the current logical line in the
           file spans multiple physical lines, the warning refers to the
           whole range, eg. "lines 3-5".  If 'line' supplied, it overrides
           the current line number; it may be a list or tuple to indicate a
           range of physical lines, or an integer for a single physical
           line.s	warning: s
N(tsyststderrtwriteR"(RRR ((s+/usr/lib64/python2.7/distutils/text_file.pytwarn�scCs�|jr$|jd}|jd=|Sd}x~|jj�}|dkrQd}n|jr�|r�|jd�}|dkr~q�|dks�||ddkr�|ddkr�dp�d}|d|!|}|j�dkr�q-q�q�|jdd�}n|jr�|r�|dkr'|j	d	�|S|j
r?|j�}n||}t|j
t�rv|j
dd|j
d<q�|j
|j
dg|_
nI|dkr�dSt|j
t�r�|j
dd|_
n|j
d|_
|jr�|jr�|j�}n0|jr|j�}n|jr,|j�}n|dksD|dkrS|jrSq-n|jr�|ddkr||d }q-n|d
dkr�|dd
!d}q-q�n|SWdS(
sURead and return a single logical line from the current file (or
           from an internal buffer if lines have previously been "unread"
           with 'unreadline()').  If the 'join_lines' option is true, this
           may involve reading multiple physical lines concatenated into a
           single string.  Updates the current line number, so calling
           'warn()' after 'readline()' emits a warning about the physical
           line(s) just read.  Returns None on end-of-file, since the empty
           string can occur if 'rstrip_ws' is true but 'strip_blanks' is
           not.i����Rt#iis\s
s\#s2continuation line immediately precedes end-of-filei����s\
N(RRtreadlineRRtfindtstriptreplaceRR(RtlstripRRRRRtrstripR(RR tbuildup_linetposteol((s+/usr/lib64/python2.7/distutils/text_file.pyR*�sf	
	
 		
	
		!	
	cCs:g}x-|j�}|dkr%|S|j|�q	WdS(sWRead and return the list of all logical lines remaining in the
           current file.N(R*RR(RtlinesR ((s+/usr/lib64/python2.7/distutils/text_file.pyt	readlinesscCs|jj|�dS(s�Push 'line' (a string) onto an internal buffer that will be
           checked by future 'readline()' calls.  Handy for implementing
           a parser with line-at-a-time lookahead.N(RR(RR ((s+/usr/lib64/python2.7/distutils/text_file.pyt
unreadline+sN(t__name__t
__module__t__doc__R	RRR
RR"R$R(R*R4R5(((s+/usr/lib64/python2.7/distutils/text_file.pyRs 8

~	((R8t__revision__R%R(((s+/usr/lib64/python2.7/distutils/text_file.pyt<module>sunixccompiler.pyc000064400000020045151702014350010141 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZmZddlm	Z	ddl
mZddlm
Z
mZmZddlmZmZmZmZdd	lmZejd
kr�ddlZnde
fd��YZdS(
s9distutils.unixccompiler

Contains the UnixCCompiler class, a subclass of CCompiler that handles
the "typical" Unix-style command-line C compiler:
  * macros defined with -Dname[=value]
  * macros undefined with -Uname
  * include search directories specified with -Idir
  * libraries specified with -lllib
  * library search directories specified with -Ldir
  * compile handled by 'cc' (or similar) executable with -c option:
    compiles .c to .o
  * link static library handled by 'ar' command (possibly with 'ranlib')
  * link shared library handled by 'cc -shared'
s$Id$i����N(t
StringTypetNoneType(t	sysconfig(tnewer(t	CCompilertgen_preprocess_optionstgen_lib_options(tDistutilsExecErrortCompileErrortLibErrort	LinkError(tlogtdarwint
UnixCCompilercBs|eZdZid(d6dgd6dgd6dgd6ddgd6dgd6d	d
gd6d(d6Zejd
 dkr�dged<nddddddgZdZdZ	dZ
dZdZdZ
ZZeZejdkr�dZnd�Zd(d(d(d(d(d�Zd�Zd(d d(d!�Zd(d(d(d(d(d d(d(d(d(d"�
Zd#�Zd$�Zd%�Zd&�Zd d'�ZRS()tunixtpreprocessortcctcompilertcompiler_sotcompiler_cxxs-sharedt	linker_sot
linker_exetars-crtarchivertranlibiRs.cs.Cs.ccs.cxxs.cpps.ms.os.as.sos.dylibs.tbdslib%s%stcygwins.execCs_tj||||�\}}}tjd�}|rR||krR|j|�n|||fS(s'Remove standard library path from rpathtLIBDIR(Rt
_fix_lib_argsRtget_config_vartremove(tselft	librariestlibrary_dirstruntime_library_dirstlibdir((s//usr/lib64/python2.7/distutils/unixccompiler.pyRXscCs	|jd||�\}}}t||�}|j|}	|rV|	jd|g�n|ri||	d*n|r|	j|�n|	j|�|js�|dks�t||�r|r�|jt	j
j|��ny|j|	�Wqt
k
r}
t|
�qXndS(Ns-oi(t_fix_compile_argstNoneRRtextendtappendtforceRtmkpathtostpathtdirnametspawnRR(Rtsourcetoutput_filetmacrostinclude_dirst
extra_preargstextra_postargstignoretpp_optstpp_argstmsg((s//usr/lib64/python2.7/distutils/unixccompiler.pyt
preprocessbs"

$c	Csz|j}tjdkr1tj|||�}ny&|j|||d|g|�Wntk
ru}t|�nXdS(NRs-o(Rtsystplatformt_osx_supporttcompiler_fixupR,RR(	Rtobjtsrctexttcc_argsR2R4RR6((s//usr/lib64/python2.7/distutils/unixccompiler.pyt_compile}s		icCs�|j||�\}}|j|d|�}|j||�r�|jtjj|��|j|j|g||j	�|j
r�y|j|j
|g�Wq�tk
r�}t|�q�Xq�nt
jd|�dS(Nt
output_dirsskipping %s (up-to-date)(t_fix_object_argstlibrary_filenamet
_need_linkR(R)R*R+R,RtobjectsRRR	Rtdebug(RREtoutput_libnameRARFttarget_langtoutput_filenameR6((s//usr/lib64/python2.7/distutils/unixccompiler.pytcreate_static_lib�s	cCs"|j||�\}}|j|||�\}}}t||||�}t|�ttfkrotd�n|dk	r�tj	j
||�}n|j||�r||j|d|g}|	r�dg|d*n|
r�|
|d*n|r�|j
|�n|jtj	j|��y�|tjkr7|j}n
|j}|
dkr�|jr�d}tj	j|d�dkr�d}x!d||kr�|d}q�Wn|j|||<ntjd	kr�tj||�}n|j||�Wqtk
r
}t|�qXntjd
|�dS(Ns%'output_dir' must be a string or Nones-os-gisc++tenvit=Rsskipping %s (up-to-date)(RBRRttypeRRt	TypeErrorR$R)R*tjoinRDRER%R(R+Rt
EXECUTABLERRRtbasenameR8R9R:R;R,RR
RRF(Rttarget_descRERIRARR R!texport_symbolsRFR1R2t
build_tempRHtlib_optstld_argstlinkertiR6((s//usr/lib64/python2.7/distutils/unixccompiler.pytlink�sD

cCsd|S(Ns-L((Rtdir((s//usr/lib64/python2.7/distutils/unixccompiler.pytlibrary_dir_option�scCsd|kpd|kS(Ntgccsg++((Rt
compiler_name((s//usr/lib64/python2.7/distutils/unixccompiler.pyt_is_gcc�scCs�tjjtjd��}tjd dkr6d|Stjd dkrQd|Stjd d	kr�|j|�r�d
d|gSdd|gStjd dks�tjd d
kr�d|gS|j|�r�d|Sd|SdS(NtCCiRs-Litfreebsds-Wl,-rpath=ishp-uxs-Wl,+ss+stirix646tosf1V5s-rpaths-Wl,-Rs-R(R)R*RQRRR8R9R^(RRZR((s//usr/lib64/python2.7/distutils/unixccompiler.pytruntime_library_dir_option�s
&
cCsd|S(Ns-l((Rtlib((s//usr/lib64/python2.7/distutils/unixccompiler.pytlibrary_optionscCs|j|dd�}|j|dd�}|j|dd�}|j|dd�}tjdkr�tjd�}tjd|�}	|	dkr�d	}
q�|	jd
�}
nxj|D]b}t	j
j||�}t	j
j||�}
t	j
j||�}t	j
j||�}tjdkr�|jd�sI|jd�r�|jd
�r�t	j
j|
|d
|�}t	j
j|
|d
|�}
t	j
j|
|d
|�}t	j
j|
|d
|�}nt	j
j
|
�r�|
St	j
j
|�r�|St	j
j
|�r�|St	j
j
|�r�|Sq�WdS(Ntlib_typetsharedtdylibt
xcode_stubtstaticRtCFLAGSs-isysroot\s+(\S+)t/is/System/s/usr/s/usr/local/(RCR8R9RRtretsearchR$tgroupR)R*ROt
startswithtexists(RtdirsRdRFtshared_ftdylib_ftxcode_stub_ftstatic_ftcflagstmtsysrootRZRgRhRjRi((s//usr/lib64/python2.7/distutils/unixccompiler.pytfind_library_files>	
N(t__name__t
__module__t
compiler_typeR$texecutablesR8R9tsrc_extensionst
obj_extensiontstatic_lib_extensiontshared_lib_extensiontdylib_lib_extensiontxcode_stub_lib_extensiontstatic_lib_formattshared_lib_formattdylib_lib_formattxcode_stub_lib_formatt
exe_extensionRR7R@RJRYR[R^RcReRz(((s//usr/lib64/python2.7/distutils/unixccompiler.pyR
0sF

6				(t__doc__t__revision__R)R8RmttypesRRt	distutilsRtdistutils.dep_utilRtdistutils.ccompilerRRRtdistutils.errorsRRR	R
RR9R:R
(((s//usr/lib64/python2.7/distutils/unixccompiler.pyt<module>s$"unixccompiler.pyo000064400000020045151702014350010155 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZmZddlm	Z	ddl
mZddlm
Z
mZmZddlmZmZmZmZdd	lmZejd
kr�ddlZnde
fd��YZdS(
s9distutils.unixccompiler

6				(t__doc__t__revision__R)R8RmttypesRRt	distutilsRtdistutils.dep_utilRtdistutils.ccompilerRRRtdistutils.errorsRRR	R
RR9R:R
(((s//usr/lib64/python2.7/distutils/unixccompiler.pyt<module>s$"util.pyc000064400000034062151702014350006241 0ustar00�
{fc@s1dZdZddlZddlZddlZddlZddlmZddlm	Z	ddl
mZddlm
Z
ddlmZd	�Zd
�Zd�Zdad
�Zd�Zdd�Zdaaad�Zd�Zdddd�Zd�Zdddddddd�Zd�ZdS(sudistutils.util

Miscellaneous utility functions -- anything that doesn't fit into
one of the other *util.py modules.
s$Id$i����N(tDistutilsPlatformError(tnewer(tspawn(tlog(tDistutilsByteCompileErrorcCs�tjdkr�d}tjtj|�}|dkr=tjStjtjd|�}tj|t|�|!j�}|dkr�dS|dkr�dStjSd	tj	kr�tj	d	Stjd
ks�t
td�r�tjStj�\}}}}}tj|�}tj|dd
�}tj|dd�}tj|dd�}|d dkrcd||fS|d dkr�|ddkr�d}dt
|d�d|df}idd6dd6}	|d|	tj7}q�n�|d  d!kr�d||fS|d d"krd#|||fS|d$ d%kred%}tjd&�}
|
j|�}|r�|j�}q�nU|d$ d'kr�dd(l}dd(l}
|j|
jj�|||�\}}}nd)|||fS(*s�Return a string that identifies the current platform.  This is used
    mainly to distinguish platform-specific build directories and
    platform-specific built distributions.  Typically includes the OS name
    and version and the architecture (as supplied by 'os.uname()'),
    although the exact information included depends on the OS; eg. for IRIX
    the architecture isn't particularly important (IRIX only runs on SGI
    hardware), but for Linux the kernel version isn't particularly
    important.

Examples of returned values:
       linux-i586
       linux-alpha (?)
       solaris-2.6-sun4u
       irix-5.3
       irix64-6.2

Windows will return one of:
       win-amd64 (64bit Windows on AMD64 (aka x86_64, Intel64, EM64T, etc)
       win-ia64 (64bit Windows on Itanium)
       win32 (all others - specifically, sys.platform is returned)

For other non-POSIX platforms, currently just returns 'sys.platform'.
    tnts bit (i����t)tamd64s	win-amd64titaniumswin-ia64t_PYTHON_HOST_PLATFORMtposixtunamet/tt t_t-itlinuxs%s-%stsunosit5tsolariss%d.%siit32biti���t64bitI�������s.%sitirixtaixs%s-%s.%sitcygwins[\d.]+tdarwinNs%s-%s-%s(tostnametstringtfindtsystversiontplatformtlentlowertenvironthasattrRtreplacetinttmaxinttretcompiletmatchtgroupt_osx_supporttdistutils.sysconfigtget_platform_osxt	sysconfigtget_config_vars(tprefixtitjtlooktosnamethosttreleaseR tmachinetbitnesstrel_retmR-t	distutils((s&/usr/lib64/python2.7/distutils/util.pytget_platformsZ "cCs�tjdkr|S|s|S|ddkr=td|�n|ddkr]td|�ntj|d�}xd|kr�|jd�qrW|s�tjStjj|�S(s�Return 'pathname' as a name that will work on the native filesystem,
    i.e. split it on '/' and put it back together again using the current
    directory separator.  Needed because filenames in the setup script are
    always supplied in Unix style, and have to be converted to the local
    convention before we can actually use them in the filesystem.  Raises
    ValueError on non-Unix-ish systems if 'pathname' either starts or
    ends with a slash.
    Rispath '%s' cannot be absolutei����spath '%s' cannot end with '/'t.(	Rtsept
ValueErrorRtsplittremovetcurdirtpathtjoin(tpathnametpaths((s&/usr/lib64/python2.7/distutils/util.pytconvert_pathns	cCstjdkrNtjj|�s4tjj||�Stjj||d�Sn�tjdkr�tjj|�\}}|ddkr�|d}ntjj||�Stjdkr�tjj|�\}}|dtjkr�|d}ntjj||�Stdtj�dS(	s	Return 'pathname' with 'new_root' prepended.  If 'pathname' is
    relative, this is equivalent to "os.path.join(new_root,pathname)".
    Otherwise, it requires making 'pathname' relative and then joining the
    two, which is tricky on DOS/Windows and Mac OS.
    R
iRis\tos2s!nothing known about platform '%s'N(RRREtisabsRFt
splitdriveR@R(tnew_rootRGtdriveRE((s&/usr/lib64/python2.7/distutils/util.pytchange_root�s

icCs�tr
dStjdkrudtjkruy0ddl}|jtj��dtjd<Wquttfk
rqquXndtjkr�t	�tjd<ndadS(sLEnsure that 'os.environ' has all the environment variables we
    guarantee that users can use in config files, command-line options,
    etc.  Currently this includes:
      HOME - user's home directory (Unix only)
      PLAT - description of the current platform, including hardware
             and OS (see 'get_platform()')
    NR
tHOMEi����itPLATi(
t_environ_checkedRRR$tpwdtgetpwuidtgetuidtImportErrortKeyErrorR>(RS((s&/usr/lib64/python2.7/distutils/util.pyt
check_environ�s	$cCsQt�|d�}ytjd||�SWn tk
rL}td|�nXdS(s�Perform shell/Perl-style variable substitution on 'string'.  Every
    occurrence of '$' followed by a name is considered a variable, and
    variable is substituted by the value found in the 'local_vars'
    dictionary, or in 'os.environ' if it's not in 'local_vars'.
    'os.environ' is first checked/augmented to guarantee that it contains
    certain values: see 'check_environ()'.  Raise ValueError for any
    variables not found in either 'local_vars' or 'os.environ'.
    cSs8|jd�}||kr)t||�Stj|SdS(Ni(R,tstrRR$(R+t
local_varstvar_name((s&/usr/lib64/python2.7/distutils/util.pyt_subst�ss\$([a-zA-Z_][a-zA-Z_0-9]*)sinvalid variable '$%s'N(RXR)tsubRWRA(tsRZR\tvar((s&/usr/lib64/python2.7/distutils/util.pyt
subst_vars�s	serror: cCs|t|�S(N(RY(texcR2((s&/usr/lib64/python2.7/distutils/util.pytgrok_environment_error�scCs8tjdtj�atjd�atjd�adS(Ns
[^\\\'\"%s ]*s'(?:[^'\\]|\\.)*'s"(?:[^"\\]|\\.)*"(R)R*Rt
whitespacet
_wordchars_ret
_squote_ret
_dquote_re(((s&/usr/lib64/python2.7/distutils/util.pyt_init_regex�scCs�td	krt�ntj|�}g}d}x�|r�tj||�}|j�}|t|�kr|j|| �Pn||tj	kr�|j|| �tj
||�}d}n�||dkr�|| ||d}|d}n�||dkrtj||�}n6||dkr<tj||�}nt
d||�|d	krmtd||�n|j�\}}|| ||d|d!||}|j�d}|t|�kr4|j|�Pq4q4W|S(
sSplit a string up according to Unix shell-like rules for quotes and
    backslashes.  In short: words are delimited by spaces, as long as those
    spaces are not escaped by a backslash, or inside a quoted string.
    Single and double quotes are equivalent, and the quote characters can
    be backslash-escaped.  The backslash is stripped from any two-character
    escape sequence, leaving only the escaped character.  The quote
    characters are stripped from any quoted string.  Returns a list of
    words.
    is\it't"s!this can't happen (bad char '%c')s"bad string (mismatched %s quotes?)iN(RdtNoneRgRtstripR+tendR"tappendRctlstripReRftRuntimeErrorRAtspan(R^twordstposR<Rltbeg((s&/usr/lib64/python2.7/distutils/util.pytsplit_quoted�sD
		
%
cCsj|dkrFd|j|f}|ddkrF|dd!d}qFntj|�|sf||�ndS(s�Perform some action that affects the outside world (eg.  by
    writing to the filesystem).  Such actions are special because they
    are disabled by the 'dry_run' flag.  This method takes care of all
    that bureaucracy for you; all you have to do is supply the
    function to call and an argument tuple for it (to embody the
    "external action" being performed), and an optional message to
    print.
    s%s%ri����s,)iRN(Rjt__name__Rtinfo(tfunctargstmsgtverbosetdry_run((s&/usr/lib64/python2.7/distutils/util.pytexecute*s	
cCsCtj|�}|dkrdS|dkr/dStd|f�dS(s�Convert a string representation of truth to true (1) or false (0).

True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
    'val' is anything else.
    tytyesttttruetont1itntnotftfalsetofft0isinvalid truth value %rN(R}R~RR�R�R�(R�R�R�R�R�R�(RR#RA(tval((s&/usr/lib64/python2.7/distutils/util.pyt	strtobool=sicCs�tjrtd��n|dkr9to3|dk}n|s�y&ddlm}|d�\}	}
Wn4tk
r�ddlm}d|d�}	}
nXt	j
d|
�|sB|	dk	r�tj|	d�}nt
|
d�}|jd	�|jtjtt|�d
�d�|jd|||||f�|j�ntj|
g}
|d
krp|
jd
d�n|dkr�|
jd
d�nt|
d|�ttj|
fd|
d|�n(ddlm}x|D]
}|ddkr�q�n|trdpd}|}|rV|t|� |krCtd||f�n|t|�}n|rttjj||�}ntjj|�}|r�|s�t||�r�t	j
d||�|s�||||�q�q�t	j d||�q�q�WdS(s�Byte-compile a collection of Python source files to either .pyc
    or .pyo files in the same directory.  'py_files' is a list of files
    to compile; any files that don't end in ".py" are silently skipped.
    'optimize' must be one of the following:
      0 - don't optimize (generate .pyc)
      1 - normal optimization (like "python -O")
      2 - extra optimization (like "python -OO")
    If 'force' is true, all files are recompiled regardless of
    timestamps.

The source filename encoded in each bytecode file defaults to the
    filenames listed in 'py_files'; you can modify these with 'prefix' and
    'basedir'.  'prefix' is a string that will be stripped off of each
    source filename, and 'base_dir' is a directory name that will be
    prepended (after 'prefix' is stripped).  You can supply either or both
    (or neither) of 'prefix' and 'base_dir', as you wish.

If 'dry_run' is true, doesn't actually do anything that would
    affect the filesystem.

Byte-compilation is either done directly in this interpreter process
    with the standard py_compile module, or indirectly by writing a
    temporary script and executing it.  Normally, you should let
    'byte_compile()' figure out to use direct compilation or not (see
    the source for details).  The 'direct' flag is used by the script
    generated in indirect mode; unless you know what you're doing, leave
    it set to None.
    sbyte-compiling is disabled.ii����(tmkstemps.py(tmktemps$writing byte-compilation script '%s'tws2from distutils.util import byte_compile
files = [
s,
s]
s�
byte_compile(files, optimize=%r, force=%r,
             prefix=%r, base_dir=%r,
             verbose=%r, dry_run=0,
             direct=1)
is-Ois-OOR{sremoving %s(R*i����tctos1invalid prefix: filename %r doesn't start with %rsbyte-compiling %s to %ss%skipping byte-compilation of %s to %sN(!Rtdont_write_bytecodeRRjt	__debug__ttempfileR�RVR�RRvRtfdopentopentwriteRRFtmaptreprtcloset
executabletinsertRR|RCt
py_compileR*R"RAREtbasenameRtdebug(tpy_filestoptimizetforceR2tbase_dirRzR{tdirectR�t	script_fdtscript_nameR�tscripttcmdR*tfiletcfiletdfilet
cfile_base((s&/usr/lib64/python2.7/distutils/util.pytbyte_compileMsh"	
&

cCs,tj|d�}tj|dd�}|S(s�Return a version of the string escaped for inclusion in an
    RFC-822 header, by ensuring there are 8 spaces space after each newline.
    s
iRs        (RRBRF(theadertlines((s&/usr/lib64/python2.7/distutils/util.pyt
rfc822_escape�s( t__doc__t__revision__RRRR)tdistutils.errorsRtdistutils.dep_utilRtdistutils.spawnRR=RRR>RIRORRRXR`RbRjRdReRfRgRtR|R�R�R�(((s&/usr/lib64/python2.7/distutils/util.pyt<module>s00	^						?	�version.pyc000064400000016050151702014350006746 0ustar00�
{fc@sqdZddlZddlZddlmZdd
d��YZdefd��YZdefd	��YZdS(s�Provides classes to represent module version numbers (one class for
each style of version numbering).  There are currently two such classes
implemented: StrictVersion and LooseVersion.

Every version number class implements the following interface:
  * the 'parse' method takes a string and parses it to some internal
    representation; if the string is an invalid version number,
    'parse' raises a ValueError exception
  * the class constructor takes an optional string argument which,
    if supplied, is passed to 'parse'
  * __str__ reconstructs the string that was passed to 'parse' (or
    an equivalent string -- ie. one that will generate an equivalent
    version number instance)
  * __repr__ generates Python code to recreate the version number instance
  * __cmp__ compares the current instance with either another instance
    of the same class or a string (which will be parsed to an instance
    of the same class, thus must follow the same rules)
i����N(t
StringTypetVersioncBs#eZdZdd�Zd�ZRS(s�Abstract base class for version numbering classes.  Just provides
    constructor (__init__) and reproducer (__repr__), because those
    seem to be the same for all version numbering classes.
    cCs|r|j|�ndS(N(tparse(tselftvstring((s)/usr/lib64/python2.7/distutils/version.pyt__init__&scCsd|jjt|�fS(Ns	%s ('%s')(t	__class__t__name__tstr(R((s)/usr/lib64/python2.7/distutils/version.pyt__repr__*sN(Rt
__module__t__doc__tNoneRR	(((s)/usr/lib64/python2.7/distutils/version.pyR st
StrictVersioncBs>eZdZejdej�Zd�Zd�Zd�Z	RS(s?Version numbering for anal retentives and software idealists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of two or three
    dot-separated numeric components, with an optional "pre-release" tag
    on the end.  The pre-release tag consists of the letter 'a' or 'b'
    followed by a number.  If the numeric components of two version
    numbers are equal, then one with a pre-release tag will always
    be deemed earlier (lesser) than one without.

The following are valid version numbers (shown in the order that
    would be obtained by sorting according to the supplied cmp function):

0.4       0.4.0  (these two are equivalent)
        0.4.1
        0.5a1
        0.5b3
        0.5
        0.9.6
        1.0
        1.0.4a3
        1.0.4b1
        1.0.4

The following are examples of invalid version numbers:

1
        2.7.2.2
        1.3.a4
        1.3pl1
        1.3c4

The rationale for this version numbering system will be explained
    in the distutils documentation.
    s)^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$cCs�|jj|�}|s(td|�n|jddddd�\}}}}}|rtttj|||g��|_n(tttj||g�dg�|_|r�|dtj|�f|_	n	d|_	dS(Nsinvalid version number '%s'iiiiii(t
version_retmatcht
ValueErrortgroupttupletmaptstringtatoitversiont
prereleaseR(RRRtmajortminortpatchRtprerelease_num((s)/usr/lib64/python2.7/distutils/version.pyRhs*'(cCs�|jddkr;tjtt|jdd!�d�}ntjtt|j�d�}|jr�||jdt|jd�}n|S(Niit.i(RRtjoinRRR(RR((s)/usr/lib64/python2.7/distutils/version.pyt__str__{s(	%cCs�t|t�rt|�}nt|j|j�}|dkr�|jrW|jrWdS|jrn|jrndS|jr�|jr�dS|jr�|jr�t|j|j�Sn|SdS(Nii����i(t
isinstanceRR
tcmpRR(Rtothertcompare((s)/usr/lib64/python2.7/distutils/version.pyt__cmp__�s(
RR
RtretcompiletVERBOSERRRR#(((s)/usr/lib64/python2.7/distutils/version.pyR
?s#			
tLooseVersioncBsSeZdZejdej�Zdd�Zd�Z	d�Z
d�Zd�ZRS(s�Version numbering for anarchists and software realists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of a series of numbers,
    separated by either periods or strings of letters.  When comparing
    version numbers, the numeric components will be compared
    numerically, and the alphabetic components lexically.  The following
    are all valid version numbers, in no particular order:

1.5.1
        1.5.2b2
        161
        3.10a
        8.02
        3.4j
        1996.07.12
        3.2.pl0
        3.1.1.6
        2g6
        11g
        0.960923
        2.2beta29
        1.13++
        5.5.kw
        2.0b1pl0

In fact, there is no such thing as an invalid version number under
    this scheme; the rules for comparison are simple and predictable,
    but may not always give the results you want (for some definition
    of "want").
    s(\d+ | [a-z]+ | \.)cCs|r|j|�ndS(N(R(RR((s)/usr/lib64/python2.7/distutils/version.pyRscCs}||_td�|jj|��}xFtt|��D]2}yt||�||<Wq:tk
rkq:Xq:W||_dS(NcSs|o|dkS(NR((tx((s)/usr/lib64/python2.7/distutils/version.pyt<lambda>t(	Rtfiltertcomponent_retsplittrangetlentintRR(RRt
componentsti((s)/usr/lib64/python2.7/distutils/version.pyRs		
cCs|jS(N(R(R((s)/usr/lib64/python2.7/distutils/version.pyRscCsdt|�S(NsLooseVersion ('%s')(R(R((s)/usr/lib64/python2.7/distutils/version.pyR	 scCs1t|t�rt|�}nt|j|j�S(N(RRR'R R(RR!((s)/usr/lib64/python2.7/distutils/version.pyR#$sN(
RR
RR$R%R&R,RRRRR	R#(((s)/usr/lib64/python2.7/distutils/version.pyR'�s			((RRR$ttypesRRR
R'(((s)/usr/lib64/python2.7/distutils/version.pyt<module>s
�versionpredicate.pyc000064400000012646151702014350010636 0ustar00�
{fc@s�dZddlZddlZddlZejd�Zejd�Zejd�Zd�Z	iej
d6ejd6ejd	6ej
d
6ejd6ejd6Zd
dd��YZdad�ZdS(sBModule for parsing and testing package version predicate strings.
i����Ns'(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)s^\s*$(.*)$\s*$s%^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$cCsPtj|�}|s(td|��n|j�\}}|tjj|�fS(sVParse a single version comparison.

Return (comparison string, StrictVersion)
    s"bad package restriction syntax: %r(tre_splitComparisontmatcht
ValueErrortgroupst	distutilstversiont
StrictVersion(tpredtrestcomptverStr((s2/usr/lib64/python2.7/distutils/versionpredicate.pytsplitUps
t<s<=s==t>s>=s!=tVersionPredicatecBs)eZdZd�Zd�Zd�ZRS(s�Parse and test package version predicates.

>>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')

The `name` attribute provides the full dotted name that is given::

>>> v.name
    'pyepat.abc'

The str() of a `VersionPredicate` provides a normalized
    human-readable version of the expression::

>>> print v
    pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)

The `satisfied_by()` method can be used to determine with a given
    version number is included in the set described by the version
    restrictions::

>>> v.satisfied_by('1.1')
    True
    >>> v.satisfied_by('1.4')
    True
    >>> v.satisfied_by('1.0')
    False
    >>> v.satisfied_by('4444.4')
    False
    >>> v.satisfied_by('1555.1b3')
    False

`VersionPredicate` is flexible in accepting extra whitespace::

>>> v = VersionPredicate(' pat( ==  0.1  )  ')
    >>> v.name
    'pat'
    >>> v.satisfied_by('0.1')
    True
    >>> v.satisfied_by('0.2')
    False

If any version numbers passed in do not conform to the
    restrictions of `StrictVersion`, a `ValueError` is raised::

>>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
    Traceback (most recent call last):
      ...
    ValueError: invalid version number '1.2zb3'

It the module or package name given does not conform to what's
    allowed as a legal module or package name, `ValueError` is
    raised::

>>> v = VersionPredicate('foo-bar')
    Traceback (most recent call last):
      ...
    ValueError: expected parenthesized list: '-bar'

>>> v = VersionPredicate('foo bar (12.21)')
    Traceback (most recent call last):
      ...
    ValueError: expected parenthesized list: 'bar (12.21)'

cCs�|j�}|s!td��ntj|�}|sItd|��n|j�\|_}|j�}|r�tj|�}|s�td|��n|j�d}g|jd�D]}t|�^q�|_	|j	s�td|��q�n	g|_	dS(s*Parse a version predicate string.
        sempty package restrictionsbad package name in %rsexpected parenthesized list: %rit,sempty parenthesized list in %rN(
tstripRtre_validPackageRRtnametre_parentsplitRR(tselftversionPredicateStrRtparentstrtaPred((s2/usr/lib64/python2.7/distutils/versionpredicate.pyt__init___s$+	cCs`|jrUg|jD] \}}|dt|�^q}|jddj|�dS|jSdS(Nt s (s, t)(RRRtjoin(Rtcondtvertseq((s2/usr/lib64/python2.7/distutils/versionpredicate.pyt__str__zs	0cCs5x.|jD]#\}}t|||�s
tSq
WtS(s�True if version is compatible with all the predicates in self.
        The parameter version must be acceptable to the StrictVersion
        constructor.  It may be either a string or StrictVersion.
        (RtcompmaptFalsetTrue(RRRR((s2/usr/lib64/python2.7/distutils/versionpredicate.pytsatisfied_by�s(t__name__t
__module__t__doc__RR!R%(((s2/usr/lib64/python2.7/distutils/versionpredicate.pyRs?		cCs�tdkrtjd�an|j�}tj|�}|sRtd|��n|jd�pdd}|r�tj	j
|�}n|jd�|fS(s9Return the name and optional version number of a provision.

The version number, if given, will be returned as a `StrictVersion`
    instance, otherwise it will be `None`.

>>> split_provision('mypkg')
    ('mypkg', None)
    >>> split_provision(' mypkg( 1.2 ) ')
    ('mypkg', StrictVersion ('1.2'))
    s=([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*$\s*([^)\s]+)\s*$)?$s"illegal provides specification: %riiN(t
_provision_rxtNonetretcompileRRRtgroupRRR(tvaluetmR((s2/usr/lib64/python2.7/distutils/versionpredicate.pytsplit_provision�s((R(R+tdistutils.versionRtoperatorR,RRRRtlttleteqtgttgetneR"RR*R)R0(((s2/usr/lib64/python2.7/distutils/versionpredicate.pyt<module>s	!!nconfig.py000064400000010046151702014350006362 0ustar00"""distutils.pypirc

Provides the PyPIRCCommand class, the base class for the command classes
that uses .pypirc in the distutils.command package.
"""
import os
from ConfigParser import ConfigParser

from distutils.cmd import Command

DEFAULT_PYPIRC = """\
[distutils]
index-servers =
    pypi

[pypi]
username:%s
password:%s
"""

class PyPIRCCommand(Command):
    """Base command that knows how to handle the .pypirc file
    """
    DEFAULT_REPOSITORY = 'https://upload.pypi.org/legacy/'
    DEFAULT_REALM = 'pypi'
    repository = None
    realm = None

user_options = [
        ('repository=', 'r',
         "url of repository [default: %s]" % \
            DEFAULT_REPOSITORY),
        ('show-response', None,
         'display full response text from server')]

boolean_options = ['show-response']

def _get_rc_file(self):
        """Returns rc file path."""
        return os.path.join(os.path.expanduser('~'), '.pypirc')

def _store_pypirc(self, username, password):
        """Creates a default .pypirc file."""
        rc = self._get_rc_file()
        f = os.fdopen(os.open(rc, os.O_CREAT | os.O_WRONLY, 0600), 'w')
        try:
            f.write(DEFAULT_PYPIRC % (username, password))
        finally:
            f.close()

def _read_pypirc(self):
        """Reads the .pypirc file."""
        rc = self._get_rc_file()
        if os.path.exists(rc):
            self.announce('Using PyPI login from %s' % rc)
            repository = self.repository or self.DEFAULT_REPOSITORY
            config = ConfigParser()
            config.read(rc)
            sections = config.sections()
            if 'distutils' in sections:
                # let's get the list of servers
                index_servers = config.get('distutils', 'index-servers')
                _servers = [server.strip() for server in
                            index_servers.split('\n')
                            if server.strip() != '']
                if _servers == []:
                    # nothing set, let's try to get the default pypi
                    if 'pypi' in sections:
                        _servers = ['pypi']
                    else:
                        # the file is not properly defined, returning
                        # an empty dict
                        return {}
                for server in _servers:
                    current = {'server': server}
                    current['username'] = config.get(server, 'username')

# optional params
                    for key, default in (('repository',
                                          self.DEFAULT_REPOSITORY),
                                         ('realm', self.DEFAULT_REALM),
                                         ('password', None)):
                        if config.has_option(server, key):
                            current[key] = config.get(server, key)
                        else:
                            current[key] = default
                    if (current['server'] == repository or
                        current['repository'] == repository):
                        return current
            elif 'server-login' in sections:
                # old format
                server = 'server-login'
                if config.has_option(server, 'repository'):
                    repository = config.get(server, 'repository')
                else:
                    repository = self.DEFAULT_REPOSITORY
                return {'username': config.get(server, 'username'),
                        'password': config.get(server, 'password'),
                        'repository': repository,
                        'server': server,
                        'realm': self.DEFAULT_REALM}

return {}

def initialize_options(self):
        """Initialize options."""
        self.repository = None
        self.realm = None
        self.show_response = 0

def finalize_options(self):
        """Finalizes options."""
        if self.repository is None:
            self.repository = self.DEFAULT_REPOSITORY
        if self.realm is None:
            self.realm = self.DEFAULT_REALM
config.pyo000064400000006755151702014350006555 0ustar00�
{fc@sRdZddlZddlmZddlmZdZdefd��YZdS(s�distutils.pypirc

core.py000064400000021473151702014350006053 0ustar00"""distutils.core

__revision__ = "$Id$"

import sys
import os

from distutils.debug import DEBUG
from distutils.errors import (DistutilsSetupError, DistutilsArgError,
                              DistutilsError, CCompilerError)

# Mainly import these so setup scripts can "from distutils.core import" them.
from distutils.dist import Distribution
from distutils.cmd import Command
from distutils.config import PyPIRCCommand
from distutils.extension import Extension

# This is a barebones help message generated displayed when the user
# runs the setup script with no arguments at all.  More useful help
# is generated with various --help options: global help, list commands,
# and per-command help.
USAGE = """\
usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
   or: %(script)s --help [cmd1 cmd2 ...]
   or: %(script)s --help-commands
   or: %(script)s cmd --help
"""

def gen_usage(script_name):
    script = os.path.basename(script_name)
    return USAGE % {'script': script}

# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'.
_setup_stop_after = None
_setup_distribution = None

# Legal keyword arguments for the setup() function
setup_keywords = ('distclass', 'script_name', 'script_args', 'options',
                  'name', 'version', 'author', 'author_email',
                  'maintainer', 'maintainer_email', 'url', 'license',
                  'description', 'long_description', 'keywords',
                  'platforms', 'classifiers', 'download_url',
                  'requires', 'provides', 'obsoletes',
                  )

# Legal keyword arguments for the Extension constructor
extension_keywords = ('name', 'sources', 'include_dirs',
                      'define_macros', 'undef_macros',
                      'library_dirs', 'libraries', 'runtime_library_dirs',
                      'extra_objects', 'extra_compile_args', 'extra_link_args',
                      'swig_opts', 'export_symbols', 'depends', 'language')

def setup(**attrs):
    """The gateway to the Distutils: do everything your setup script needs
    to do, in a highly flexible and user-driven way.  Briefly: create a
    Distribution instance; find and parse config files; parse the command
    line; run each Distutils command found there, customized by the options
    supplied to 'setup()' (as keyword arguments), in config files, and on
    the command line.

The Distribution instance might be an instance of a class supplied via
    the 'distclass' keyword argument to 'setup'; if no such class is
    supplied, then the Distribution class (in dist.py) is instantiated.
    All other arguments to 'setup' (except for 'cmdclass') are used to set
    attributes of the Distribution instance.

The 'cmdclass' argument, if supplied, is a dictionary mapping command
    names to command classes.  Each command encountered on the command line
    will be turned into a command class, which is in turn instantiated; any
    class found in 'cmdclass' is used in place of the default, which is
    (for command 'foo_bar') class 'foo_bar' in module
    'distutils.command.foo_bar'.  The command class must provide a
    'user_options' attribute which is a list of option specifiers for
    'distutils.fancy_getopt'.  Any command-line options between the current
    and the next command are used to set attributes of the current command
    object.

When the entire command-line has been successfully parsed, calls the
    'run()' method on each command object in turn.  This method will be
    driven entirely by the Distribution object (which each command object
    has a reference to, thanks to its constructor), and the
    command-specific options that became attributes of each command
    object.
    """

global _setup_stop_after, _setup_distribution

# Determine the distribution class -- either caller-supplied or
    # our Distribution (see below).
    klass = attrs.get('distclass')
    if klass:
        del attrs['distclass']
    else:
        klass = Distribution

if 'script_name' not in attrs:
        attrs['script_name'] = os.path.basename(sys.argv[0])
    if 'script_args' not in attrs:
        attrs['script_args'] = sys.argv[1:]

# Create the Distribution instance, using the remaining arguments
    # (ie. everything except distclass) to initialize it
    try:
        _setup_distribution = dist = klass(attrs)
    except DistutilsSetupError, msg:
        if 'name' in attrs:
            raise SystemExit, "error in %s setup command: %s" % \
                  (attrs['name'], msg)
        else:
            raise SystemExit, "error in setup command: %s" % msg

if _setup_stop_after == "init":
        return dist

# Find and parse the config file(s): they will override options from
    # the setup script, but be overridden by the command line.
    dist.parse_config_files()

if DEBUG:
        print "options (after parsing config files):"
        dist.dump_option_dicts()

if _setup_stop_after == "config":
        return dist

# Parse the command line and override config files; any
    # command-line errors are the end user's fault, so turn them into
    # SystemExit to suppress tracebacks.
    try:
        ok = dist.parse_command_line()
    except DistutilsArgError, msg:
        raise SystemExit, gen_usage(dist.script_name) + "\nerror: %s" % msg

if DEBUG:
        print "options (after parsing command line):"
        dist.dump_option_dicts()

if _setup_stop_after == "commandline":
        return dist

# And finally, run all the commands found on the command line.
    if ok:
        try:
            dist.run_commands()
        except KeyboardInterrupt:
            raise SystemExit, "interrupted"
        except (IOError, os.error), exc:
            if DEBUG:
                sys.stderr.write("error: %s\n" % (exc,))
                raise
            else:
                raise SystemExit, "error: %s" % (exc,)

except (DistutilsError,
                CCompilerError), msg:
            if DEBUG:
                raise
            else:
                raise SystemExit, "error: " + str(msg)

return dist

def run_setup(script_name, script_args=None, stop_after="run"):
    """Run a setup script in a somewhat controlled environment, and
    return the Distribution instance that drives things.  This is useful
    if you need to find out the distribution meta-data (passed as
    keyword args from 'script' to 'setup()', or the contents of the
    config files or command-line.

'script_name' is a file that will be run with 'execfile()';
    'sys.argv[0]' will be replaced with 'script' for the duration of the
    call.  'script_args' is a list of strings; if supplied,
    'sys.argv[1:]' will be replaced by 'script_args' for the duration of
    the call.

'stop_after' tells 'setup()' when to stop processing; possible
    values:
      init
        stop after the Distribution instance has been created and
        populated with the keyword arguments to 'setup()'
      config
        stop after config files have been parsed (and their data
        stored in the Distribution instance)
      commandline
        stop after the command-line ('sys.argv[1:]' or 'script_args')
        have been parsed (and the data stored in the Distribution)
      run [default]
        stop after all commands have been run (the same as if 'setup()'
        had been called in the usual way

Returns the Distribution instance, which provides all information
    used to drive the Distutils.
    """
    if stop_after not in ('init', 'config', 'commandline', 'run'):
        raise ValueError, "invalid value for 'stop_after': %r" % (stop_after,)

global _setup_stop_after, _setup_distribution
    _setup_stop_after = stop_after

save_argv = sys.argv
    g = {'__file__': script_name}
    l = {}
    try:
        try:
            sys.argv[0] = script_name
            if script_args is not None:
                sys.argv[1:] = script_args
            f = open(script_name)
            try:
                exec f.read() in g, l
            finally:
                f.close()
        finally:
            sys.argv = save_argv
            _setup_stop_after = None
    except SystemExit:
        # Hmm, should we do something if exiting with a non-zero code
        # (ie. error)?
        pass
    except:
        raise

if _setup_distribution is None:
        raise RuntimeError, \
              ("'distutils.core.setup()' was never called -- "
               "perhaps '%s' is not a Distutils setup script?") % \
              script_name

# I wonder if the setup script's namespace -- g and l -- would be of
    # any interest to callers?
    return _setup_distribution
core.pyc000064400000016560151702014350006217 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZmZm	Z	m
Z
ddlmZddl
mZddlmZdd	lmZd
Zd�Zdadad2Zd3Zd/�Zdd0d1�ZdS(4s#distutils.core

The only module that needs to be imported to use the Distutils; provides
the 'setup' function (which is to be called from the setup script).  Also
indirectly provides the Distribution and Command classes, although they are
really defined in distutils.dist and distutils.cmd.
s$Id$i����N(tDEBUG(tDistutilsSetupErrortDistutilsArgErrortDistutilsErrortCCompilerError(tDistribution(tCommand(t
PyPIRCCommand(t	Extensions�usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
   or: %(script)s --help [cmd1 cmd2 ...]
   or: %(script)s --help-commands
   or: %(script)s cmd --help
cCs!tjj|�}ti|d6S(Ntscript(tostpathtbasenametUSAGE(tscript_nameR	((s&/usr/lib64/python2.7/distutils/core.pyt	gen_usage#st	distclassRtscript_argstoptionstnametversiontauthortauthor_emailt
maintainertmaintainer_emailturltlicensetdescriptiontlong_descriptiontkeywordst	platformstclassifierstdownload_urltrequirestprovidest	obsoletestsourcestinclude_dirst
define_macrostundef_macrostlibrary_dirst	librariestruntime_library_dirst
extra_objectstextra_compile_argstextra_link_argst	swig_optstexport_symbolstdependstlanguagecKs5|jd�}|r|d=nt}d|krQtjjtjd�|d<nd|krqtjd|d<ny||�a}WnFtk
r�}d|kr�t	d|d|f�q�t	d|�nXt
d	kr�|S|j�trd
GH|j
�nt
dkr|Sy|j�}Wn-tk
rO}t	t|j�d|�nXtrhd
GH|j
�nt
dkrx|S|r1y|j�Wq1tk
r�t	d�q1ttjfk
r�}tr�tjjd|f��q.t	d|f�q1ttfk
r-}tr�q.t	dt|��q1Xn|S(s�The gateway to the Distutils: do everything your setup script needs
    to do, in a highly flexible and user-driven way.  Briefly: create a
    Distribution instance; find and parse config files; parse the command
    line; run each Distutils command found there, customized by the options
    supplied to 'setup()' (as keyword arguments), in config files, and on
    the command line.

error: %ss%options (after parsing command line):tcommandlinetinterrupteds
error: %s
s	error: %sserror: (tgetRR
RRtsystargvt_setup_distributionRt
SystemExitt_setup_stop_aftertparse_config_filesRtdump_option_dictstparse_command_lineRRRtrun_commandstKeyboardInterrupttIOErrorterrortstderrtwriteRRtstr(tattrstklasstdisttmsgtoktexc((s&/usr/lib64/python2.7/distutils/core.pytsetup<s`%

truncBs�|dkred|f�n|aej}i|d6}i}yrz[|ejd<|d	k	rp|ejd)ne|�}z|j�||UWd	|j�XWd	|e_d	aXWnek
r�n
�nXt	d	kr�e
d
|�nt	S(s)Run a setup script in a somewhat controlled environment, and
    return the Distribution instance that drives things.  This is useful
    if you need to find out the distribution meta-data (passed as
    keyword args from 'script' to 'setup()', or the contents of the
    config files or command-line.

Returns the Distribution instance, which provides all information
    used to drive the Distutils.
    R2R3R4RMs"invalid value for 'stop_after': %rt__file__iiNsZ'distutils.core.setup()' was never called -- perhaps '%s' is not a Distutils setup script?(R2R3R4RM(t
ValueErrorR;R7R8tNonetopentreadtcloseR:R9tRuntimeError(RRt
stop_aftert	save_argvtgtltf((s&/usr/lib64/python2.7/distutils/core.pyt	run_setup�s4

(RRRRRRRRRRRRRRRRRR R!R"R#(RR$R%R&R'R(R)R*R+R,R-R.R/R0R1(t__doc__t__revision__R7R
tdistutils.debugRtdistutils.errorsRRRRtdistutils.distRt
distutils.cmdRtdistutils.configRtdistutils.extensionRR
RRPR;R9tsetup_keywordstextension_keywordsRLRZ(((s&/usr/lib64/python2.7/distutils/core.pyt<module>s4"		ocore.pyo000064400000016560151702014350006233 0ustar00�
{fc@s�dZdZddlZddlZddlmZddlmZmZm	Z	m
Z
ddlmZddl
mZddlmZdd	lmZd
Zd�Zdadad2Zd3Zd/�Zdd0d1�ZdS(4s#distutils.core

(RRRRRRRRRRRRRRRRRR R!R"R#(RR$R%R&R'R(R)R*R+R,R-R.R/R0R1(t__doc__t__revision__R7R
tdistutils.debugRtdistutils.errorsRRRRtdistutils.distRt
distutils.cmdRtdistutils.configRtdistutils.extensionRR
RRPR;R9tsetup_keywordstextension_keywordsRLRZ(((s&/usr/lib64/python2.7/distutils/core.pyt<module>s4"		ocygwinccompiler.py000064400000042507151702014350010322 0ustar00"""distutils.cygwinccompiler

# problems:
#
# * if you use a msvc compiled python version (1.5.2)
#   1. you have to insert a __GNUC__ section in its config.h
#   2. you have to generate an import library for its dll
#      - create a def-file for python??.dll
#      - create an import library using
#             dlltool --dllname python15.dll --def python15.def \
#                       --output-lib libpython15.a
#
#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
#
# * We put export_symbols in a def-file, and don't use
#   --export-all-symbols because it doesn't worked reliable in some
#   tested configurations. And because other windows compilers also
#   need their symbols specified this no serious problem.
#
# tested configurations:
#
# * cygwin gcc 2.91.57/ld 2.9.4/dllwrap 0.2.4 works
#   (after patching python's config.h and for C++ some other include files)
#   see also http://starship.python.net/crew/kernr/mingw32/Notes.html
# * mingw32 gcc 2.95.2/ld 2.9.4/dllwrap 0.2.4 works
#   (ld doesn't support -shared, so we use dllwrap)
# * cygwin gcc 2.95.2/ld 2.10.90/dllwrap 2.10.90 works now
#   - its dllwrap doesn't work, there is a bug in binutils 2.10.90
#     see also http://sources.redhat.com/ml/cygwin/2000-06/msg01274.html
#   - using gcc -mdll instead dllwrap doesn't work without -static because
#     it tries to link against dlls instead their import libraries. (If
#     it finds the dll first.)
#     By specifying -static we force ld to link against the import libraries,
#     this is windows standard and there are normally not the necessary symbols
#     in the dlls.
#   *** only the version of June 2000 shows these problems
# * cygwin gcc 3.2/ld 2.13.90 works
#   (ld supports -shared)
# * mingw gcc 3.2/ld 2.13 works
#   (ld supports -shared)

# This module should be kept compatible with Python 2.1.

__revision__ = "$Id$"

import os,sys,copy
from distutils.ccompiler import gen_preprocess_options, gen_lib_options
from distutils.unixccompiler import UnixCCompiler
from distutils.file_util import write_file
from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
from distutils import log

def get_msvcr():
    """Include the appropriate MSVC runtime library if Python was built
    with MSVC 7.0 or later.
    """
    msc_pos = sys.version.find('MSC v.')
    if msc_pos != -1:
        msc_ver = sys.version[msc_pos+6:msc_pos+10]
        if msc_ver == '1300':
            # MSVC 7.0
            return ['msvcr70']
        elif msc_ver == '1310':
            # MSVC 7.1
            return ['msvcr71']
        elif msc_ver == '1400':
            # VS2005 / MSVC 8.0
            return ['msvcr80']
        elif msc_ver == '1500':
            # VS2008 / MSVC 9.0
            return ['msvcr90']
        else:
            raise ValueError("Unknown MS Compiler version %s " % msc_ver)

class CygwinCCompiler (UnixCCompiler):

compiler_type = 'cygwin'
    obj_extension = ".o"
    static_lib_extension = ".a"
    shared_lib_extension = ".dll"
    static_lib_format = "lib%s%s"
    shared_lib_format = "%s%s"
    exe_extension = ".exe"

def __init__ (self, verbose=0, dry_run=0, force=0):

UnixCCompiler.__init__ (self, verbose, dry_run, force)

(status, details) = check_config_h()
        self.debug_print("Python's GCC status: %s (details: %s)" %
                         (status, details))
        if status is not CONFIG_H_OK:
            self.warn(
                "Python's pyconfig.h doesn't seem to support your compiler. "
                "Reason: %s. "
                "Compiling may fail because of undefined preprocessor macros."
                % details)

self.gcc_version, self.ld_version, self.dllwrap_version = \
            get_versions()
        self.debug_print(self.compiler_type + ": gcc %s, ld %s, dllwrap %s\n" %
                         (self.gcc_version,
                          self.ld_version,
                          self.dllwrap_version) )

# ld_version >= "2.10.90" and < "2.13" should also be able to use
        # gcc -mdll instead of dllwrap
        # Older dllwraps had own version numbers, newer ones use the
        # same as the rest of binutils ( also ld )
        # dllwrap 2.10.90 is buggy
        if self.ld_version >= "2.10.90":
            self.linker_dll = "gcc"
        else:
            self.linker_dll = "dllwrap"

# ld_version >= "2.13" support -shared so use it instead of
        # -mdll -static
        if self.ld_version >= "2.13":
            shared_option = "-shared"
        else:
            shared_option = "-mdll -static"

# Hard-code GCC because that's what this is all about.
        # XXX optimization, warnings etc. should be customizable.
        self.set_executables(compiler='gcc -mcygwin -O -Wall',
                             compiler_so='gcc -mcygwin -mdll -O -Wall',
                             compiler_cxx='g++ -mcygwin -O -Wall',
                             linker_exe='gcc -mcygwin',
                             linker_so=('%s -mcygwin %s' %
                                        (self.linker_dll, shared_option)))

# cygwin and mingw32 need different sets of libraries
        if self.gcc_version == "2.91.57":
            # cygwin shouldn't need msvcrt, but without the dlls will crash
            # (gcc version 2.91.57) -- perhaps something about initialization
            self.dll_libraries=["msvcrt"]
            self.warn(
                "Consider upgrading to a newer version of gcc")
        else:
            # Include the appropriate MSVC runtime library if Python was built
            # with MSVC 7.0 or later.
            self.dll_libraries = get_msvcr()

# __init__ ()

def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        if ext == '.rc' or ext == '.res':
            # gcc needs '.res' and '.rc' compiled to object files !!!
            try:
                self.spawn(["windres", "-i", src, "-o", obj])
            except DistutilsExecError, msg:
                raise CompileError, msg
        else: # for other files use the C-compiler
            try:
                self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
                           extra_postargs)
            except DistutilsExecError, msg:
                raise CompileError, msg

# use separate copies, so we can modify the lists
        extra_preargs = copy.copy(extra_preargs or [])
        libraries = copy.copy(libraries or [])
        objects = copy.copy(objects or [])

# Additional libraries
        libraries.extend(self.dll_libraries)

# handle export symbols by creating a def-file
        # with executables this only works with gcc/ld as linker
        if ((export_symbols is not None) and
            (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):
            # (The linker doesn't do anything if output is up-to-date.
            # So it would probably better to check if we really need this,
            # but for this we had to insert some unchanged parts of
            # UnixCCompiler, and this is not what we want.)

# we want to put some files in the same directory as the
            # object files are, build_temp doesn't help much
            # where are the object files
            temp_dir = os.path.dirname(objects[0])
            # name of dll to give the helper files the same base name
            (dll_name, dll_extension) = os.path.splitext(
                os.path.basename(output_filename))

# generate the filenames for these files
            def_file = os.path.join(temp_dir, dll_name + ".def")
            lib_file = os.path.join(temp_dir, 'lib' + dll_name + ".a")

# Generate .def file
            contents = [
                "LIBRARY %s" % os.path.basename(output_filename),
                "EXPORTS"]
            for sym in export_symbols:
                contents.append(sym)
            self.execute(write_file, (def_file, contents),
                         "writing %s" % def_file)

# next add options for def-file and to creating import libraries

# dllwrap uses different options than gcc/ld
            if self.linker_dll == "dllwrap":
                extra_preargs.extend(["--output-lib", lib_file])
                # for dllwrap we have to use a special option
                extra_preargs.extend(["--def", def_file])
            # we use gcc/ld here and can be sure ld is >= 2.9.10
            else:
                # doesn't work: bfd_close build\...\libfoo.a: Invalid operation
                #extra_preargs.extend(["-Wl,--out-implib,%s" % lib_file])
                # for gcc/ld the def-file is specified as any object files
                objects.append(def_file)

#end: if ((export_symbols is not None) and
        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):

# who wants symbols and a many times larger output file
        # should explicitly switch the debug mode on
        # otherwise we let dllwrap/ld strip the output file
        # (On my machine: 10KB < stripped_file < ??100KB
        #   unstripped_file = stripped_file + XXX KB
        #  ( XXX=254 for a typical python extension))
        if not debug:
            extra_preargs.append("-s")

UnixCCompiler.link(self,
                           target_desc,
                           objects,
                           output_filename,
                           output_dir,
                           libraries,
                           library_dirs,
                           runtime_library_dirs,
                           None, # export_symbols, we do this in our def-file
                           debug,
                           extra_preargs,
                           extra_postargs,
                           build_temp,
                           target_lang)

# link ()

# -- Miscellaneous methods -----------------------------------------

# overwrite the one from CCompiler to support rc and res-files
    def object_filenames (self,
                          source_filenames,
                          strip_dir=0,
                          output_dir=''):
        if output_dir is None: output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
            (base, ext) = os.path.splitext (os.path.normcase(src_name))
            if ext not in (self.src_extensions + ['.rc','.res']):
                raise UnknownFileError, \
                      "unknown file type '%s' (from '%s')" % \
                      (ext, src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext == '.res' or ext == '.rc':
                # these need to be compiled to object files
                obj_names.append (os.path.join (output_dir,
                                            base + ext + self.obj_extension))
            else:
                obj_names.append (os.path.join (output_dir,
                                            base + self.obj_extension))
        return obj_names

# object_filenames ()

# class CygwinCCompiler

# the same as cygwin plus some additional parameters
class Mingw32CCompiler (CygwinCCompiler):

compiler_type = 'mingw32'

def __init__ (self,
                  verbose=0,
                  dry_run=0,
                  force=0):

CygwinCCompiler.__init__ (self, verbose, dry_run, force)

# A real mingw32 doesn't need to specify a different entry point,
        # but cygwin 2.91.57 in no-cygwin-mode needs it.
        if self.gcc_version <= "2.91.57":
            entry_point = '--entry _DllMain@12'
        else:
            entry_point = ''

if self.gcc_version < '4' or is_cygwingcc():
            no_cygwin = ' -mno-cygwin'
        else:
            no_cygwin = ''

self.set_executables(compiler='gcc%s -O -Wall' % no_cygwin,
                             compiler_so='gcc%s -mdll -O -Wall' % no_cygwin,
                             compiler_cxx='g++%s -O -Wall' % no_cygwin,
                             linker_exe='gcc%s' % no_cygwin,
                             linker_so='%s%s %s %s'
                                    % (self.linker_dll, no_cygwin,
                                       shared_option, entry_point))
        # Maybe we should also append -mthreads, but then the finished
        # dlls need another dll (mingwm10.dll see Mingw32 docs)
        # (-mthreads: Support thread-safe exception handling on `Mingw32')

# no additional libraries needed
        self.dll_libraries=[]

# Include the appropriate MSVC runtime library if Python was built
        # with MSVC 7.0 or later.
        self.dll_libraries = get_msvcr()

# __init__ ()

# class Mingw32CCompiler

# Because these compilers aren't configured in Python's pyconfig.h file by
# default, we should at least warn the user if he is using an unmodified
# version.

CONFIG_H_OK = "ok"
CONFIG_H_NOTOK = "not ok"
CONFIG_H_UNCERTAIN = "uncertain"

def check_config_h():

"""Check if the current Python installation (specifically, pyconfig.h)
    appears amenable to building extensions with GCC.  Returns a tuple
    (status, details), where 'status' is one of the following constants:
      CONFIG_H_OK
        all is well, go ahead and compile
      CONFIG_H_NOTOK
        doesn't look good
      CONFIG_H_UNCERTAIN
        not sure -- unable to read pyconfig.h
    'details' is a human-readable string explaining the situation.

# XXX since this function also checks sys.version, it's not strictly a
    # "pyconfig.h" check -- should probably be renamed...

from distutils import sysconfig
    import string
    # if sys.version contains GCC then python was compiled with
    # GCC, and the pyconfig.h file should be OK
    if string.find(sys.version,"GCC") >= 0:
        return (CONFIG_H_OK, "sys.version mentions 'GCC'")

fn = sysconfig.get_config_h_filename()
    try:
        # It would probably better to read single lines to search.
        # But we do this only once, and it is fast enough
        f = open(fn)
        try:
            s = f.read()
        finally:
            f.close()

except IOError, exc:
        # if we can't read this file, we cannot say it is wrong
        # the compiler will complain later about this file as missing
        return (CONFIG_H_UNCERTAIN,
                "couldn't read '%s': %s" % (fn, exc.strerror))

else:
        # "pyconfig.h" contains an "#ifdef __GNUC__" or something similar
        if string.find(s,"__GNUC__") >= 0:
            return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
        else:
            return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)

def get_versions():
    """ Try to find out the versions of gcc, ld and dllwrap.
        If not possible it returns None for it.
    """
    from distutils.version import LooseVersion
    from distutils.spawn import find_executable
    import re

gcc_exe = find_executable('gcc')
    if gcc_exe:
        out = os.popen(gcc_exe + ' -dumpversion','r')
        out_string = out.read()
        out.close()
        result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
        if result:
            gcc_version = LooseVersion(result.group(1))
        else:
            gcc_version = None
    else:
        gcc_version = None
    ld_exe = find_executable('ld')
    if ld_exe:
        out = os.popen(ld_exe + ' -v','r')
        out_string = out.read()
        out.close()
        result = re.search('(\d+\.\d+(\.\d+)*)',out_string)
        if result:
            ld_version = LooseVersion(result.group(1))
        else:
            ld_version = None
    else:
        ld_version = None
    dllwrap_exe = find_executable('dllwrap')
    if dllwrap_exe:
        out = os.popen(dllwrap_exe + ' --version','r')
        out_string = out.read()
        out.close()
        result = re.search(' (\d+\.\d+(\.\d+)*)',out_string)
        if result:
            dllwrap_version = LooseVersion(result.group(1))
        else:
            dllwrap_version = None
    else:
        dllwrap_version = None
    return (gcc_version, ld_version, dllwrap_version)

def is_cygwingcc():
    '''Try to determine if the gcc that would be used is from cygwin.'''
    out = os.popen('gcc -dumpmachine', 'r')
    out_string = out.read()
    out.close()
    # out_string is the target triplet cpu-vendor-os
    # Cygwin's gcc sets the os to 'cygwin'
    return out_string.strip().endswith('cygwin')
cygwinccompiler.pyo000064400000023141151702014350010472 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZmZddlm	Z	ddl
mZddlm
Z
mZmZddlmZd	�Zd
e	fd��YZdefd
��YZdZdZdZd�Zd�Zd�ZdS(sdistutils.cygwinccompiler

Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
handles the Cygwin port of the GNU C compiler to Windows.  It also contains
the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
cygwin in no-cygwin mode).
s$Id$i����N(tgen_preprocess_optionstgen_lib_options(t
UnixCCompiler(t
write_file(tDistutilsExecErrortCompileErrortUnknownFileError(tlogcCs�tjjd�}|dkr�tj|d|d!}|dkrIdgS|dkr\dgS|d	krod
gS|dkr�dgStd
|��ndS(saInclude the appropriate MSVC runtime library if Python was built
    with MSVC 7.0 or later.
    sMSC v.i����ii
t1300tmsvcr70t1310tmsvcr71t1400tmsvcr80t1500tmsvcr90sUnknown MS Compiler version %s N(tsystversiontfindt
ValueError(tmsc_postmsc_ver((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyt	get_msvcr;stCygwinCCompilercBs�eZdZdZdZdZdZdZdZdddd�Z	d	�Z
d
d
d
d
d
dd
d
d
d
d
�
Zddd�Z
RS(tcygwins.os.as.dllslib%s%ss%s%ss.exeic
CsStj||||�t�\}}|jd||f�|tk	r\|jd|�nt�\|_|_|_	|j|j
d|j|j|j	f�|jdkr�d|_n	d|_|jdkr�d}nd	}|jd
ddd
dddddd|j|f�|jdkrCdg|_
|jd�nt�|_
dS(Ns%Python's GCC status: %s (details: %s)s�Python's pyconfig.h doesn't seem to support your compiler. Reason: %s. Compiling may fail because of undefined preprocessor macros.s: gcc %s, ld %s, dllwrap %s
s2.10.90tgcctdllwraps2.13s-shareds
-mdll -statictcompilersgcc -mcygwin -O -Walltcompiler_sosgcc -mcygwin -mdll -O -Walltcompiler_cxxsg++ -mcygwin -O -Wallt
linker_exesgcc -mcygwint	linker_sos%s -mcygwin %ss2.91.57tmsvcrts,Consider upgrading to a newer version of gcc(Rt__init__tcheck_config_htdebug_printtCONFIG_H_OKtwarntget_versionstgcc_versiont
ld_versiontdllwrap_versiont
compiler_typet
linker_dlltset_executablest
dll_librariesR(tselftverbosetdry_runtforcetstatustdetailst
shared_option((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyR!\s<			
cCs�|dks|dkrZy |jdd|d|g�Wq�tk
rV}t|�q�XnHy)|j|j||d|g|�Wntk
r�}t|�nXdS(Ns.rcs.restwindress-is-o(tspawnRRR(R.tobjtsrctexttcc_argstextra_postargstpp_optstmsg((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyt_compile�s cCs�tj|
pg�}
tj|p$g�}tj|p9g�}|j|j�|dk	r�||jksy|jdkr�tjj|d�}tjj	tjj
|��\}}tjj||d�}tjj|d|d�}dtjj
|�dg}x|D]}|j|�qW|j
t||fd|�|jd	krx|
jd
|g�|
jd|g�q�|j|�n|	s�|
jd�ntj||||||||d|	|
|||
�dS(
NRis.deftlibs.as
LIBRARY %stEXPORTSs
writing %sRs--output-libs--defs-s(tcopytextendR-tNonet
EXECUTABLER+tostpathtdirnametsplitexttbasenametjointappendtexecuteRRtlink(R.ttarget_desctobjectstoutput_filenamet
output_dirt	librariestlibrary_dirstruntime_library_dirstexport_symbolstdebugt
extra_preargsR;t
build_tempttarget_langttemp_dirtdll_namet
dll_extensiontdef_filetlib_filetcontentstsym((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyRM�sJ			
	tcCs|dkrd}ng}x�|D]�}tjjtjj|��\}}||jddgkr{td||f�n|r�tjj|�}n|dks�|dkr�|jtjj	||||j
��q"|jtjj	|||j
��q"W|S(NRas.rcs.ress"unknown file type '%s' (from '%s')(RCRERFRHtnormcasetsrc_extensionsRRIRKRJt
obj_extension(R.tsource_filenamest	strip_dirRQt	obj_namestsrc_nametbaseR9((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pytobject_filenamess"	
$N(t__name__t
__module__R*Rdtstatic_lib_extensiontshared_lib_extensiontstatic_lib_formattshared_lib_formatt
exe_extensionR!R>RCRMRj(((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyRRs*>	XtMingw32CCompilercBs eZdZdddd�ZRS(tmingw32icCs�tj||||�|jdkr.d}nd}|jdkrLd}nd}|jdksjt�rsd}nd}|jd	d
|dd|d
d|dd|dd|j|||f�g|_t�|_dS(Ns2.13s-shareds
-mdll -statics2.91.57s--entry _DllMain@12Rat4s -mno-cygwinRsgcc%s -O -WallRsgcc%s -mdll -O -WallRsg++%s -O -WallRsgcc%sRs
%s%s %s %s(	RR!R(R'tis_cygwingccR,R+R-R(R.R/R0R1R4tentry_pointt	no_cygwin((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyR!-s&

(RkRlR*R!(((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyRr)stoksnot okt	uncertaincCs�ddlm}ddl}|jtjd�dkrAtdfS|j�}y.t|�}z|j	�}Wd|j
�XWn'tk
r�}td||j
ffSX|j|d�dkr�td	|fStd
|fSdS(s�Check if the current Python installation (specifically, pyconfig.h)
    appears amenable to building extensions with GCC.  Returns a tuple
    (status, details), where 'status' is one of the following constants:
      CONFIG_H_OK
        all is well, go ahead and compile
      CONFIG_H_NOTOK
        doesn't look good
      CONFIG_H_UNCERTAIN
        not sure -- unable to read pyconfig.h
    'details' is a human-readable string explaining the situation.

Note there are two ways to conclude "OK": either 'sys.version' contains
    the string "GCC" (implying that this Python was built with GCC), or the
    installed "pyconfig.h" contains the string "__GNUC__".
    i����(t	sysconfigNtGCCissys.version mentions 'GCC'scouldn't read '%s': %st__GNUC__s'%s' mentions '__GNUC__'s '%s' does not mention '__GNUC__'(t	distutilsRztstringRRRR$tget_config_h_filenametopentreadtclosetIOErrortCONFIG_H_UNCERTAINtstrerrortCONFIG_H_NOTOK(RzR~tfntftstexc((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyR"es 
cCs�ddlm}ddlm}ddl}|d�}|r�tj|dd�}|j�}|j�|j	d|�}|r�||j
d	��}q�d}nd}|d
�}|r tj|dd�}|j�}|j�|j	d|�}|r||j
d	��}	q&d}	nd}	|d�}
|
r�tj|
d
d�}|j�}|j�|j	d|�}|r�||j
d	��}q�d}nd}||	|fS(sj Try to find out the versions of gcc, ld and dllwrap.
        If not possible it returns None for it.
    i����(tLooseVersion(tfind_executableNRs
 -dumpversiontrs(\d+\.\d+(\.\d+)*)itlds -vRs
 --versions (\d+\.\d+(\.\d+)*)(tdistutils.versionR�tdistutils.spawnR�treREtpopenR�R�tsearchtgroupRC(R�R�R�tgcc_exetoutt
out_stringtresultR'tld_exeR(tdllwrap_exeR)((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyR&�sD
	
	
	cCs;tjdd�}|j�}|j�|j�jd�S(s>Try to determine if the gcc that would be used is from cygwin.sgcc -dumpmachineR�R(RER�R�R�tstriptendswith(R�R�((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyRu�s
(t__doc__t__revision__RERRAtdistutils.ccompilerRRtdistutils.unixccompilerRtdistutils.file_utilRtdistutils.errorsRRRR}RRRRrR$R�R�R"R&Ru(((s1/usr/lib64/python2.7/distutils/cygwinccompiler.pyt<module>s +$	�8	5	.debug.py000064400000000242151702014350006200 0ustar00import os

__revision__ = "$Id$"

# If DISTUTILS_DEBUG is anything other than the empty string, we run in
# debug mode.
DEBUG = os.environ.get('DISTUTILS_DEBUG')
debug.pyc000064400000000376151702014350006353 0ustar00�
{fc@s(ddlZdZejjd�ZdS(i����Ns$Id$tDISTUTILS_DEBUG(tost__revision__tenvirontgettDEBUG(((s'/usr/lib64/python2.7/distutils/debug.pyt<module>sdebug.pyo000064400000000376151702014350006367 0ustar00�
{fc@s(ddlZdZejjd�ZdS(i����Ns$Id$tDISTUTILS_DEBUG(tost__revision__tenvirontgettDEBUG(((s'/usr/lib64/python2.7/distutils/debug.pyt<module>sdep_util.py000064400000006665151702014350006736 0ustar00"""distutils.dep_util

Utility functions for simple, timestamp-based dependency of files
and groups of files; also, function based entirely on such
timestamp dependency analysis."""

__revision__ = "$Id$"

import os
from stat import ST_MTIME
from distutils.errors import DistutilsFileError

def newer(source, target):
    """Tells if the target is newer than the source.

Return true if 'source' exists and is more recently modified than
    'target', or if 'source' exists and 'target' doesn't.

Return false if both exist and 'target' is the same age or younger
    than 'source'. Raise DistutilsFileError if 'source' does not exist.

Note that this test is not very accurate: files created in the same second
    will have the same "age".
    """
    if not os.path.exists(source):
        raise DistutilsFileError("file '%s' does not exist" %
                                 os.path.abspath(source))
    if not os.path.exists(target):
        return True

return os.stat(source)[ST_MTIME] > os.stat(target)[ST_MTIME]

def newer_pairwise(sources, targets):
    """Walk two filename lists in parallel, testing if each source is newer
    than its corresponding target.  Return a pair of lists (sources,
    targets) where source is newer than target, according to the semantics
    of 'newer()'.
    """
    if len(sources) != len(targets):
        raise ValueError, "'sources' and 'targets' must be same length"

# build a pair of lists (sources, targets) where  source is newer
    n_sources = []
    n_targets = []
    for source, target in zip(sources, targets):
        if newer(source, target):
            n_sources.append(source)
            n_targets.append(target)

return n_sources, n_targets

def newer_group(sources, target, missing='error'):
    """Return true if 'target' is out-of-date with respect to any file
    listed in 'sources'.

In other words, if 'target' exists and is newer
    than every file in 'sources', return false; otherwise return true.
    'missing' controls what we do when a source file is missing; the
    default ("error") is to blow up with an OSError from inside 'stat()';
    if it is "ignore", we silently drop any missing source files; if it is
    "newer", any missing source files make us assume that 'target' is
    out-of-date (this is handy in "dry-run" mode: it'll make you pretend to
    carry out commands that wouldn't work because inputs are missing, but
    that doesn't matter because you're not actually going to run the
    commands).
    """
    # If the target doesn't even exist, then it's definitely out-of-date.
    if not os.path.exists(target):
        return True

# Otherwise we have to find out the hard way: if *any* source file
    # is more recent than 'target', then 'target' is out-of-date and
    # we can immediately return true.  If we fall through to the end
    # of the loop, then 'target' is up-to-date and we return false.
    target_mtime = os.stat(target)[ST_MTIME]

for source in sources:
        if not os.path.exists(source):
            if missing == 'error':      # blow up when we stat() the file
                pass
            elif missing == 'ignore':   # missing source dropped from
                continue                #  target's dependency list
            elif missing == 'newer':    # missing source means target is
                return True             #  out-of-date

if os.stat(source)[ST_MTIME] > target_mtime:
            return True

return False
dep_util.pyc000064400000006154151702014350007072 0ustar00�
{fc@sZdZdZddlZddlmZddlmZd�Zd�Zdd	�Z	dS(
s�distutils.dep_util

Utility functions for simple, timestamp-based dependency of files
and groups of files; also, function based entirely on such
timestamp dependency analysis.s$Id$i����N(tST_MTIME(tDistutilsFileErrorcCsktjj|�s1tdtjj|���ntjj|�sGtStj|�ttj|�tkS(s�Tells if the target is newer than the source.

Return true if 'source' exists and is more recently modified than
    'target', or if 'source' exists and 'target' doesn't.

Return false if both exist and 'target' is the same age or younger
    than 'source'. Raise DistutilsFileError if 'source' does not exist.

Note that this test is not very accurate: files created in the same second
    will have the same "age".
    sfile '%s' does not exist(tostpathtexistsRtabspathtTruetstatR(tsourcettarget((s*/usr/lib64/python2.7/distutils/dep_util.pytnewer
scCs�t|�t|�kr$td�ng}g}xIt||�D]8\}}t||�r@|j|�|j|�q@q@W||fS(s�Walk two filename lists in parallel, testing if each source is newer
    than its corresponding target.  Return a pair of lists (sources,
    targets) where source is newer than target, according to the semantics
    of 'newer()'.
    s+'sources' and 'targets' must be same length(tlent
ValueErrortzipR
tappend(tsourcesttargetst	n_sourcest	n_targetsRR	((s*/usr/lib64/python2.7/distutils/dep_util.pytnewer_pairwise!s
terrorcCs�tjj|�stStj|�t}xq|D]i}tjj|�s||dkrWq||dkriq0q||dkr|tSntj|�t|kr0tSq0WtS(s�Return true if 'target' is out-of-date with respect to any file
    listed in 'sources'.

In other words, if 'target' exists and is newer
    than every file in 'sources', return false; otherwise return true.
    'missing' controls what we do when a source file is missing; the
    default ("error") is to blow up with an OSError from inside 'stat()';
    if it is "ignore", we silently drop any missing source files; if it is
    "newer", any missing source files make us assume that 'target' is
    out-of-date (this is handy in "dry-run" mode: it'll make you pretend to
    carry out commands that wouldn't work because inputs are missing, but
    that doesn't matter because you're not actually going to run the
    commands).
    RtignoreR
(RRRRRRtFalse(RR	tmissingttarget_mtimeR((s*/usr/lib64/python2.7/distutils/dep_util.pytnewer_group4s
(
t__doc__t__revision__RRRtdistutils.errorsRR
RR(((s*/usr/lib64/python2.7/distutils/dep_util.pyt<module>s		dep_util.pyo000064400000006154151702014350007106 0ustar00�
{fc@sZdZdZddlZddlmZddlmZd�Zd�Zdd	�Z	dS(
s�distutils.dep_util

Return true if 'source' exists and is more recently modified than
    'target', or if 'source' exists and 'target' doesn't.

Return false if both exist and 'target' is the same age or younger
    than 'source'. Raise DistutilsFileError if 'source' does not exist.

In other words, if 'target' exists and is newer
    than every file in 'sources', return false; otherwise return true.
    'missing' controls what we do when a source file is missing; the
    default ("error") is to blow up with an OSError from inside 'stat()';
    if it is "ignore", we silently drop any missing source files; if it is
    "newer", any missing source files make us assume that 'target' is
    out-of-date (this is handy in "dry-run" mode: it'll make you pretend to
    carry out commands that wouldn't work because inputs are missing, but
    that doesn't matter because you're not actually going to run the
    commands).
    RtignoreR
(RRRRRRtFalse(RR	tmissingttarget_mtimeR((s*/usr/lib64/python2.7/distutils/dep_util.pytnewer_group4s
(
t__doc__t__revision__RRRtdistutils.errorsRR
RR(((s*/usr/lib64/python2.7/distutils/dep_util.pyt<module>s		dir_util.py000064400000017274151702014350006742 0ustar00"""distutils.dir_util

Utility functions for manipulating directories and directory trees."""

__revision__ = "$Id$"

import os
import errno
from distutils.errors import DistutilsFileError, DistutilsInternalError
from distutils import log

# cache for by mkpath() -- in addition to cheapening redundant calls,
# eliminates redundant "creating /foo/bar/baz" messages in dry-run mode
_path_created = {}

# I don't use os.makedirs because a) it's new to Python 1.5.2, and
# b) it blows up if the directory already exists (I want to silently
# succeed in that case).
def mkpath(name, mode=0777, verbose=1, dry_run=0):
    """Create a directory and any missing ancestor directories.

global _path_created

# Detect a common bug -- name is None
    if not isinstance(name, basestring):
        raise DistutilsInternalError, \
              "mkpath: 'name' must be a string (got %r)" % (name,)

# XXX what's the better way to handle verbosity? print as we create
    # each directory in the path (the current behaviour), or only announce
    # the creation of the whole path? (quite easy to do the latter since
    # we're not using a recursive algorithm)

name = os.path.normpath(name)
    created_dirs = []
    if os.path.isdir(name) or name == '':
        return created_dirs
    if _path_created.get(os.path.abspath(name)):
        return created_dirs

(head, tail) = os.path.split(name)
    tails = [tail]                      # stack of lone dirs to create

while head and tail and not os.path.isdir(head):
        (head, tail) = os.path.split(head)
        tails.insert(0, tail)          # push next higher dir onto stack

# now 'head' contains the deepest directory that already exists
    # (that is, the child of 'head' in 'name' is the highest directory
    # that does *not* exist)
    for d in tails:
        #print "head = %s, d = %s: " % (head, d),
        head = os.path.join(head, d)
        abs_head = os.path.abspath(head)

if _path_created.get(abs_head):
            continue

if verbose >= 1:
            log.info("creating %s", head)

if not dry_run:
            try:
                os.mkdir(head, mode)
            except OSError, exc:
                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
                    raise DistutilsFileError(
                          "could not create '%s': %s" % (head, exc.args[-1]))
            created_dirs.append(head)

_path_created[abs_head] = 1
    return created_dirs

def create_tree(base_dir, files, mode=0777, verbose=1, dry_run=0):
    """Create all the empty directories under 'base_dir' needed to put 'files'
    there.

'base_dir' is just the name of a directory which doesn't necessarily
    exist yet; 'files' is a list of filenames to be interpreted relative to
    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
    will be created if it doesn't already exist.  'mode', 'verbose' and
    'dry_run' flags are as for 'mkpath()'.
    """
    # First get the list of directories to create
    need_dir = {}
    for file in files:
        need_dir[os.path.join(base_dir, os.path.dirname(file))] = 1
    need_dirs = need_dir.keys()
    need_dirs.sort()

# Now create them
    for dir in need_dirs:
        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)

def copy_tree(src, dst, preserve_mode=1, preserve_times=1,
              preserve_symlinks=0, update=0, verbose=1, dry_run=0):
    """Copy an entire directory tree 'src' to a new location 'dst'.

Both 'src' and 'dst' must be directory names.  If 'src' is not a
    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
    created with 'mkpath()'.  The end result of the copy is that every
    file in 'src' is copied to 'dst', and directories under 'src' are
    recursively copied to 'dst'.  Return the list of files that were
    copied or might have been copied, using their output name.  The
    return value is unaffected by 'update' or 'dry_run': it is simply
    the list of all files under 'src', with the names changed to be
    under 'dst'.

if not dry_run and not os.path.isdir(src):
        raise DistutilsFileError, \
              "cannot copy tree '%s': not a directory" % src
    try:
        names = os.listdir(src)
    except os.error, (errno, errstr):
        if dry_run:
            names = []
        else:
            raise DistutilsFileError, \
                  "error listing files in '%s': %s" % (src, errstr)

if not dry_run:
        mkpath(dst, verbose=verbose)

outputs = []

for n in names:
        src_name = os.path.join(src, n)
        dst_name = os.path.join(dst, n)

if n.startswith('.nfs'):
            # skip NFS rename files
            continue

if preserve_symlinks and os.path.islink(src_name):
            link_dest = os.readlink(src_name)
            if verbose >= 1:
                log.info("linking %s -> %s", dst_name, link_dest)
            if not dry_run:
                os.symlink(link_dest, dst_name)
            outputs.append(dst_name)

elif os.path.isdir(src_name):
            outputs.extend(
                copy_tree(src_name, dst_name, preserve_mode,
                          preserve_times, preserve_symlinks, update,
                          verbose=verbose, dry_run=dry_run))
        else:
            copy_file(src_name, dst_name, preserve_mode,
                      preserve_times, update, verbose=verbose,
                      dry_run=dry_run)
            outputs.append(dst_name)

return outputs

def _build_cmdtuple(path, cmdtuples):
    """Helper for remove_tree()."""
    for f in os.listdir(path):
        real_f = os.path.join(path,f)
        if os.path.isdir(real_f) and not os.path.islink(real_f):
            _build_cmdtuple(real_f, cmdtuples)
        else:
            cmdtuples.append((os.remove, real_f))
    cmdtuples.append((os.rmdir, path))

def remove_tree(directory, verbose=1, dry_run=0):
    """Recursively remove an entire directory tree.

Any errors are ignored (apart from being reported to stdout if 'verbose'
    is true).
    """
    global _path_created

if verbose >= 1:
        log.info("removing '%s' (and everything under it)", directory)
    if dry_run:
        return
    cmdtuples = []
    _build_cmdtuple(directory, cmdtuples)
    for cmd in cmdtuples:
        try:
            cmd[0](cmd[1])
            # remove dir from cache if it's already there
            abspath = os.path.abspath(cmd[1])
            if abspath in _path_created:
                del _path_created[abspath]
        except (IOError, OSError), exc:
            log.warn("error removing %s: %s", directory, exc)

def ensure_relative(path):
    """Take the full path 'path', and make it a relative path.

This is useful to make 'path' the second argument to os.path.join().
    """
    drive, path = os.path.splitdrive(path)
    if path[0:1] == os.sep:
        path = drive + path[1:]
    return path
dir_util.pyc000064400000015202151702014350007072 0ustar00�
{fc@s�dZdZddlZddlZddlmZmZddlmZia	dddd	�Z
dddd
�Zddddddd�Zd�Z
ddd
�Zd�ZdS(sWdistutils.dir_util

Utility functions for manipulating directories and directory trees.s$Id$i����N(tDistutilsFileErrortDistutilsInternalError(tlogi�iicCs�t|t�s"td|f�ntjj|�}g}tjj|�sX|dkr\|Stjtjj	|��r{|Stjj
|�\}}|g}xK|r�|r�tjj|�r�tjj
|�\}}|jd|�q�Wx�|D]�}tjj||�}tjj	|�}	tj|	�r3q�n|dkrRt
jd|�n|s�ytj||�WnWtk
r�}
|
jtjko�tjj|�s�td||
jdf��q�nX|j|�ndt|	<q�W|S(s�Create a directory and any missing ancestor directories.

If the directory already exists (or if 'name' is the empty string, which
    means the current directory, which of course exists), then do nothing.
    Raise DistutilsFileError if unable to create some directory along the way
    (eg. some sub-path exists, but is a file rather than a directory).
    If 'verbose' is true, print a one-line summary of each mkdir to stdout.
    Return the list of directories actually created.
    s(mkpath: 'name' must be a string (got %r)tiiscreating %sscould not create '%s': %si����(t
isinstancet
basestringRtostpathtnormpathtisdirt
_path_createdtgettabspathtsplittinserttjoinRtinfotmkdirtOSErrorterrnotEEXISTRtargstappend(tnametmodetverbosetdry_runtcreated_dirstheadttailttailstdtabs_headtexc((s*/usr/lib64/python2.7/distutils/dir_util.pytmkpaths>	"
$!c	Cs�i}x3|D]+}d|tjj|tjj|��<q
W|j�}|j�x'|D]}t||d|d|�qYWdS(s�Create all the empty directories under 'base_dir' needed to put 'files'
    there.

'base_dir' is just the name of a directory which doesn't necessarily
    exist yet; 'files' is a list of filenames to be interpreted relative to
    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
    will be created if it doesn't already exist.  'mode', 'verbose' and
    'dry_run' flags are as for 'mkpath()'.
    iRRN(RRRtdirnametkeystsortR"(	tbase_dirtfilesRRRtneed_dirtfilet	need_dirstdir((s*/usr/lib64/python2.7/distutils/dir_util.pytcreate_treeRs
)

c
Cs�ddlm}|r:tjj|�r:td|�nytj|�}	Wn>tjk
r�\}
}|rwg}	q�td||f�nX|s�t|d|�ng}x1|	D])}
tjj	||
�}tjj	||
�}|
j
d�r�q�n|rktjj|�rktj|�}|dkrBt
jd||�n|s[tj||�n|j|�q�tjj|�r�|jt||||||d|d	|��q�||||||d|d	|�|j|�q�W|S(
sCopy an entire directory tree 'src' to a new location 'dst'.

'preserve_mode' and 'preserve_times' are the same as for
    'copy_file'; note that they only apply to regular files, not to
    directories.  If 'preserve_symlinks' is true, symlinks will be
    copied as symlinks (on platforms that support them!); otherwise
    (the default), the destination of the symlink will be copied.
    'update' and 'verbose' are the same as for 'copy_file'.
    i����(t	copy_files&cannot copy tree '%s': not a directoryserror listing files in '%s': %sRs.nfsislinking %s -> %sR(tdistutils.file_utilR-RRR	RtlistdirterrorR"Rt
startswithtislinktreadlinkRRtsymlinkRtextendt	copy_tree(tsrctdstt
preserve_modetpreserve_timestpreserve_symlinkstupdateRRR-tnamesRterrstrtoutputstntsrc_nametdst_namet	link_dest((s*/usr/lib64/python2.7/distutils/dir_util.pyR6gsH
	
cCs�xwtj|�D]f}tjj||�}tjj|�r`tjj|�r`t||�q|jtj|f�qW|jtj	|f�dS(sHelper for remove_tree().N(
RR/RRR	R2t_build_cmdtupleRtremovetrmdir(Rt	cmdtuplestftreal_f((s*/usr/lib64/python2.7/distutils/dir_util.pyRD�s%cCs�|dkrtjd|�n|r)dSg}t||�x|D]w}yB|d|d�tjj|d�}|tkr�t|=nWqCttfk
r�}tj	d||�qCXqCWdS(s�Recursively remove an entire directory tree.

Any errors are ignored (apart from being reported to stdout if 'verbose'
    is true).
    is'removing '%s' (and everything under it)Niserror removing %s: %s(
RRRDRRRR
tIOErrorRtwarn(t	directoryRRRGtcmdRR!((s*/usr/lib64/python2.7/distutils/dir_util.pytremove_tree�s

cCsCtjj|�\}}|dd!tjkr?||d}n|S(s�Take the full path 'path', and make it a relative path.

This is useful to make 'path' the second argument to os.path.join().
    ii(RRt
splitdrivetsep(Rtdrive((s*/usr/lib64/python2.7/distutils/dir_util.pytensure_relative�s(t__doc__t__revision__RRtdistutils.errorsRRt	distutilsRR
R"R,R6RDRNRR(((s*/usr/lib64/python2.7/distutils/dir_util.pyt<module>s?D	
dir_util.pyo000064400000015202151702014350007106 0ustar00�
{fc@s�dZdZddlZddlZddlmZmZddlmZia	dddd	�Z
dddd
�Zddddddd�Zd�Z
ddd
�Zd�ZdS(sWdistutils.dir_util

'base_dir' is just the name of a directory which doesn't necessarily
    exist yet; 'files' is a list of filenames to be interpreted relative to
    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
    will be created if it doesn't already exist.  'mode', 'verbose' and
    'dry_run' flags are as for 'mkpath()'.
    iRRN(RRRtdirnametkeystsortR"(	tbase_dirtfilesRRRtneed_dirtfilet	need_dirstdir((s*/usr/lib64/python2.7/distutils/dir_util.pytcreate_treeRs
)

cCsCtjj|�\}}|dd!tjkr?||d}n|S(s�Take the full path 'path', and make it a relative path.

This is useful to make 'path' the second argument to os.path.join().
    ii(RRt
splitdrivetsep(Rtdrive((s*/usr/lib64/python2.7/distutils/dir_util.pytensure_relative�s(t__doc__t__revision__RRtdistutils.errorsRRt	distutilsRR
R"R,R6RDRNRR(((s*/usr/lib64/python2.7/distutils/dir_util.pyt<module>s?D	
dist.py000064400000141601151702014350006062 0ustar00"""distutils.dist

Provides the Distribution class, which represents the module distribution
being built/installed/distributed.
"""

__revision__ = "$Id$"

import sys, os, re
from email import message_from_file

try:
    import warnings
except ImportError:
    warnings = None

from distutils.errors import (DistutilsOptionError, DistutilsArgError,
                              DistutilsModuleError, DistutilsClassError)
from distutils.fancy_getopt import FancyGetopt, translate_longopt
from distutils.util import check_environ, strtobool, rfc822_escape
from distutils import log
from distutils.debug import DEBUG

# Encoding used for the PKG-INFO files
PKG_INFO_ENCODING = 'utf-8'

# Regex to define acceptable Distutils command names.  This is not *quite*
# the same as a Python NAME -- I don't allow leading underscores.  The fact
# that they're very similar is no coincidence; the default naming scheme is
# to look for a Python module named after the command.
command_re = re.compile (r'^[a-zA-Z]([a-zA-Z0-9_]*)$')

class Distribution:
    """The core of the Distutils.  Most of the work hiding behind 'setup'
    is really done within a Distribution instance, which farms the work out
    to the Distutils commands specified on the command line.

# 'global_options' describes the command-line options that may be
    # supplied to the setup script prior to any actual commands.
    # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
    # these global options.  This list should be kept to a bare minimum,
    # since every global option is also valid as a command option -- and we
    # don't want to pollute the commands with too many options that they
    # have minimal control over.
    # The fourth entry for verbose means that it can be repeated.
    global_options = [('verbose', 'v', "run verbosely (default)", 1),
                      ('quiet', 'q', "run quietly (turns verbosity off)"),
                      ('dry-run', 'n', "don't actually do anything"),
                      ('help', 'h', "show detailed help message"),
                      ('no-user-cfg', None,
                       'ignore pydistutils.cfg in your home directory'),
    ]

# 'common_usage' is a short (2-3 line) string describing the common
    # usage of the setup script.
    common_usage = """\
Common commands: (see '--help-commands' for more)

setup.py build      will build the package underneath 'build/'
  setup.py install    will install the package
"""

# options that are not propagated to the commands
    display_options = [
        ('help-commands', None,
         "list all available commands"),
        ('name', None,
         "print package name"),
        ('version', 'V',
         "print package version"),
        ('fullname', None,
         "print <package name>-<version>"),
        ('author', None,
         "print the author's name"),
        ('author-email', None,
         "print the author's email address"),
        ('maintainer', None,
         "print the maintainer's name"),
        ('maintainer-email', None,
         "print the maintainer's email address"),
        ('contact', None,
         "print the maintainer's name if known, else the author's"),
        ('contact-email', None,
         "print the maintainer's email address if known, else the author's"),
        ('url', None,
         "print the URL for this package"),
        ('license', None,
         "print the license of the package"),
        ('licence', None,
         "alias for --license"),
        ('description', None,
         "print the package description"),
        ('long-description', None,
         "print the long package description"),
        ('platforms', None,
         "print the list of platforms"),
        ('classifiers', None,
         "print the list of classifiers"),
        ('keywords', None,
         "print the list of keywords"),
        ('provides', None,
         "print the list of packages/modules provided"),
        ('requires', None,
         "print the list of packages/modules required"),
        ('obsoletes', None,
         "print the list of packages/modules made obsolete")
        ]
    display_option_names = map(lambda x: translate_longopt(x[0]),
                               display_options)

# negative options are options that exclude other options
    negative_opt = {'quiet': 'verbose'}

# -- Creation/initialization methods -------------------------------

def __init__ (self, attrs=None):
        """Construct a new Distribution instance: initialize all the
        attributes of a Distribution, and then use 'attrs' (a dictionary
        mapping attribute names to values) to assign some of those
        attributes their "real" values.  (Any attributes not mentioned in
        'attrs' will be assigned to some null value: 0, None, an empty list
        or dictionary, etc.)  Most importantly, initialize the
        'command_obj' attribute to the empty dictionary; this will be
        filled in with real command objects by 'parse_command_line()'.
        """

# Default values for our command-line options
        self.verbose = 1
        self.dry_run = 0
        self.help = 0
        for attr in self.display_option_names:
            setattr(self, attr, 0)

# Store the distribution meta-data (name, version, author, and so
        # forth) in a separate object -- we're getting to have enough
        # information here (and enough command-line options) that it's
        # worth it.  Also delegate 'get_XXX()' methods to the 'metadata'
        # object in a sneaky and underhanded (but efficient!) way.
        self.metadata = DistributionMetadata()
        for basename in self.metadata._METHOD_BASENAMES:
            method_name = "get_" + basename
            setattr(self, method_name, getattr(self.metadata, method_name))

# 'cmdclass' maps command names to class objects, so we
        # can 1) quickly figure out which class to instantiate when
        # we need to create a new command object, and 2) have a way
        # for the setup script to override command classes
        self.cmdclass = {}

# 'command_packages' is a list of packages in which commands
        # are searched for.  The factory for command 'foo' is expected
        # to be named 'foo' in the module 'foo' in one of the packages
        # named here.  This list is searched from the left; an error
        # is raised if no named package provides the command being
        # searched for.  (Always access using get_command_packages().)
        self.command_packages = None

# 'script_name' and 'script_args' are usually set to sys.argv[0]
        # and sys.argv[1:], but they can be overridden when the caller is
        # not necessarily a setup script run from the command-line.
        self.script_name = None
        self.script_args = None

# 'command_options' is where we store command options between
        # parsing them (from config files, the command-line, etc.) and when
        # they are actually needed -- ie. when the command in question is
        # instantiated.  It is a dictionary of dictionaries of 2-tuples:
        #   command_options = { command_name : { option : (source, value) } }
        self.command_options = {}

# 'dist_files' is the list of (command, pyversion, file) that
        # have been created by any dist commands run so far. This is
        # filled regardless of whether the run is dry or not. pyversion
        # gives sysconfig.get_python_version() if the dist file is
        # specific to a Python version, 'any' if it is good for all
        # Python versions on the target platform, and '' for a source
        # file. pyversion should not be used to specify minimum or
        # maximum required Python versions; use the metainfo for that
        # instead.
        self.dist_files = []

# These options are really the business of various commands, rather
        # than of the Distribution itself.  We provide aliases for them in
        # Distribution as a convenience to the developer.
        self.packages = None
        self.package_data = {}
        self.package_dir = None
        self.py_modules = None
        self.libraries = None
        self.headers = None
        self.ext_modules = None
        self.ext_package = None
        self.include_dirs = None
        self.extra_path = None
        self.scripts = None
        self.data_files = None
        self.password = ''

# And now initialize bookkeeping stuff that can't be supplied by
        # the caller at all.  'command_obj' maps command names to
        # Command instances -- that's how we enforce that every command
        # class is a singleton.
        self.command_obj = {}

# 'have_run' maps command names to boolean values; it keeps track
        # of whether we have actually run a particular command, to make it
        # cheap to "run" a command whenever we think we might need to -- if
        # it's already been done, no need for expensive filesystem
        # operations, we just check the 'have_run' dictionary and carry on.
        # It's only safe to query 'have_run' for a command class that has
        # been instantiated -- a false value will be inserted when the
        # command object is created, and replaced with a true value when
        # the command is successfully run.  Thus it's probably best to use
        # '.get()' rather than a straight lookup.
        self.have_run = {}

# Now we'll use the attrs dictionary (ultimately, keyword args from
        # the setup script) to possibly override any or all of these
        # distribution options.

if attrs:
            # Pull out the set of command options and work on them
            # specifically.  Note that this order guarantees that aliased
            # command options will override any supplied redundantly
            # through the general options dictionary.
            options = attrs.get('options')
            if options is not None:
                del attrs['options']
                for (command, cmd_options) in options.items():
                    opt_dict = self.get_option_dict(command)
                    for (opt, val) in cmd_options.items():
                        opt_dict[opt] = ("setup script", val)

if 'licence' in attrs:
                attrs['license'] = attrs['licence']
                del attrs['licence']
                msg = "'licence' distribution option is deprecated; use 'license'"
                if warnings is not None:
                    warnings.warn(msg)
                else:
                    sys.stderr.write(msg + "\n")

# Now work on the rest of the attributes.  Any attribute that's
            # not already defined is invalid!
            for (key, val) in attrs.items():
                if hasattr(self.metadata, "set_" + key):
                    getattr(self.metadata, "set_" + key)(val)
                elif hasattr(self.metadata, key):
                    setattr(self.metadata, key, val)
                elif hasattr(self, key):
                    setattr(self, key, val)
                else:
                    msg = "Unknown distribution option: %s" % repr(key)
                    if warnings is not None:
                        warnings.warn(msg)
                    else:
                        sys.stderr.write(msg + "\n")

# no-user-cfg is handled before other command line args
        # because other args override the config files, and this
        # one is needed before we can load the config files.
        # If attrs['script_args'] wasn't passed, assume false.
        #
        # This also make sure we just look at the global options
        self.want_user_cfg = True

if self.script_args is not None:
            for arg in self.script_args:
                if not arg.startswith('-'):
                    break
                if arg == '--no-user-cfg':
                    self.want_user_cfg = False
                    break

self.finalize_options()

def get_option_dict(self, command):
        """Get the option dictionary for a given command.  If that
        command's option dictionary hasn't been created yet, then create it
        and return the new dictionary; otherwise, return the existing
        option dictionary.
        """
        dict = self.command_options.get(command)
        if dict is None:
            dict = self.command_options[command] = {}
        return dict

def dump_option_dicts(self, header=None, commands=None, indent=""):
        from pprint import pformat

if commands is None:             # dump all command option dicts
            commands = self.command_options.keys()
            commands.sort()

if header is not None:
            self.announce(indent + header)
            indent = indent + "  "

if not commands:
            self.announce(indent + "no commands known yet")
            return

for cmd_name in commands:
            opt_dict = self.command_options.get(cmd_name)
            if opt_dict is None:
                self.announce(indent +
                              "no option dict for '%s' command" % cmd_name)
            else:
                self.announce(indent +
                              "option dict for '%s' command:" % cmd_name)
                out = pformat(opt_dict)
                for line in out.split('\n'):
                    self.announce(indent + "  " + line)

# -- Config file finding/parsing methods ---------------------------

def find_config_files(self):
        """Find as many configuration files as should be processed for this
        platform, and return a list of filenames in the order in which they
        should be parsed.  The filenames returned are guaranteed to exist
        (modulo nasty race conditions).

There are three possible config files: distutils.cfg in the
        Distutils installation directory (ie. where the top-level
        Distutils __inst__.py file lives), a file in the user's home
        directory named .pydistutils.cfg on Unix and pydistutils.cfg
        on Windows/Mac; and setup.cfg in the current directory.

The file in the user's home directory can be disabled with the
        --no-user-cfg option.
        """
        files = []
        check_environ()

# Where to look for the system-wide Distutils config file
        sys_dir = os.path.dirname(sys.modules['distutils'].__file__)

# Look for the system config file
        sys_file = os.path.join(sys_dir, "distutils.cfg")
        if os.path.isfile(sys_file):
            files.append(sys_file)

# What to call the per-user config file
        if os.name == 'posix':
            user_filename = ".pydistutils.cfg"
        else:
            user_filename = "pydistutils.cfg"

# And look for the user config file
        if self.want_user_cfg:
            user_file = os.path.join(os.path.expanduser('~'), user_filename)
            if os.path.isfile(user_file):
                files.append(user_file)

# All platforms support local setup.cfg
        local_file = "setup.cfg"
        if os.path.isfile(local_file):
            files.append(local_file)

if DEBUG:
            self.announce("using config files: %s" % ', '.join(files))

return files

def parse_config_files(self, filenames=None):
        from ConfigParser import ConfigParser

if filenames is None:
            filenames = self.find_config_files()

if DEBUG:
            self.announce("Distribution.parse_config_files():")

parser = ConfigParser()
        for filename in filenames:
            if DEBUG:
                self.announce("  reading %s" % filename)
            parser.read(filename)
            for section in parser.sections():
                options = parser.options(section)
                opt_dict = self.get_option_dict(section)

for opt in options:
                    if opt != '__name__':
                        val = parser.get(section,opt)
                        opt = opt.replace('-', '_')
                        opt_dict[opt] = (filename, val)

# Make the ConfigParser forget everything (so we retain
            # the original filenames that options come from)
            parser.__init__()

# If there was a "global" section in the config file, use it
        # to set Distribution options.

if 'global' in self.command_options:
            for (opt, (src, val)) in self.command_options['global'].items():
                alias = self.negative_opt.get(opt)
                try:
                    if alias:
                        setattr(self, alias, not strtobool(val))
                    elif opt in ('verbose', 'dry_run'): # ugh!
                        setattr(self, opt, strtobool(val))
                    else:
                        setattr(self, opt, val)
                except ValueError, msg:
                    raise DistutilsOptionError, msg

# -- Command-line parsing methods ----------------------------------

def parse_command_line(self):
        """Parse the setup script's command line, taken from the
        'script_args' instance attribute (which defaults to 'sys.argv[1:]'
        -- see 'setup()' in core.py).  This list is first processed for
        "global options" -- options that set attributes of the Distribution
        instance.  Then, it is alternately scanned for Distutils commands
        and options for that command.  Each new command terminates the
        options for the previous command.  The allowed options for a
        command are determined by the 'user_options' attribute of the
        command class -- thus, we have to be able to load command classes
        in order to parse the command line.  Any error in that 'options'
        attribute raises DistutilsGetoptError; any error on the
        command-line raises DistutilsArgError.  If no Distutils commands
        were found on the command line, raises DistutilsArgError.  Return
        true if command-line was successfully parsed and we should carry
        on with executing commands; false if no errors but we shouldn't
        execute commands (currently, this only happens if user asks for
        help).
        """
        #
        # We now have enough information to show the Macintosh dialog
        # that allows the user to interactively specify the "command line".
        #
        toplevel_options = self._get_toplevel_options()

# We have to parse the command line a bit at a time -- global
        # options, then the first command, then its options, and so on --
        # because each command will be handled by a different class, and
        # the options that are valid for a particular class aren't known
        # until we have loaded the command class, which doesn't happen
        # until we know what the command is.

self.commands = []
        parser = FancyGetopt(toplevel_options + self.display_options)
        parser.set_negative_aliases(self.negative_opt)
        parser.set_aliases({'licence': 'license'})
        args = parser.getopt(args=self.script_args, object=self)
        option_order = parser.get_option_order()
        log.set_verbosity(self.verbose)

# for display options we return immediately
        if self.handle_display_options(option_order):
            return
        while args:
            args = self._parse_command_opts(parser, args)
            if args is None:            # user asked for help (and got it)
                return

# Handle the cases of --help as a "global" option, ie.
        # "setup.py --help" and "setup.py --help command ...".  For the
        # former, we show global options (--verbose, --dry-run, etc.)
        # and display-only options (--name, --version, etc.); for the
        # latter, we omit the display-only options and show help for
        # each command listed on the command line.
        if self.help:
            self._show_help(parser,
                            display_options=len(self.commands) == 0,
                            commands=self.commands)
            return

# Oops, no commands found -- an end-user error
        if not self.commands:
            raise DistutilsArgError, "no commands supplied"

# All is well: return true
        return 1

def _get_toplevel_options(self):
        """Return the non-display options recognized at the top level.

This includes options that are recognized *only* at the top
        level as well as options recognized for commands.
        """
        return self.global_options + [
            ("command-packages=", None,
             "list of packages that provide distutils commands"),
            ]

def _parse_command_opts(self, parser, args):
        """Parse the command-line options for a single command.
        'parser' must be a FancyGetopt instance; 'args' must be the list
        of arguments, starting with the current command (whose options
        we are about to parse).  Returns a new version of 'args' with
        the next command at the front of the list; will be the empty
        list if there are no more commands on the command line.  Returns
        None if the user asked for help on this command.
        """
        # late import because of mutual dependence between these modules
        from distutils.cmd import Command

# Pull the current command from the head of the command line
        command = args[0]
        if not command_re.match(command):
            raise SystemExit, "invalid command name '%s'" % command
        self.commands.append(command)

# Dig up the command class that implements this command, so we
        # 1) know that it's a valid command, and 2) know which options
        # it takes.
        try:
            cmd_class = self.get_command_class(command)
        except DistutilsModuleError, msg:
            raise DistutilsArgError, msg

# Require that the command class be derived from Command -- want
        # to be sure that the basic "command" interface is implemented.
        if not issubclass(cmd_class, Command):
            raise DistutilsClassError, \
                  "command class %s must subclass Command" % cmd_class

# Also make sure that the command object provides a list of its
        # known options.
        if not (hasattr(cmd_class, 'user_options') and
                isinstance(cmd_class.user_options, list)):
            raise DistutilsClassError, \
                  ("command class %s must provide " +
                   "'user_options' attribute (a list of tuples)") % \
                  cmd_class

# If the command class has a list of negative alias options,
        # merge it in with the global negative aliases.
        negative_opt = self.negative_opt
        if hasattr(cmd_class, 'negative_opt'):
            negative_opt = negative_opt.copy()
            negative_opt.update(cmd_class.negative_opt)

# Check for help_options in command class.  They have a different
        # format (tuple of four) so we need to preprocess them here.
        if (hasattr(cmd_class, 'help_options') and
            isinstance(cmd_class.help_options, list)):
            help_options = fix_help_options(cmd_class.help_options)
        else:
            help_options = []

# All commands support the global options too, just by adding
        # in 'global_options'.
        parser.set_option_table(self.global_options +
                                cmd_class.user_options +
                                help_options)
        parser.set_negative_aliases(negative_opt)
        (args, opts) = parser.getopt(args[1:])
        if hasattr(opts, 'help') and opts.help:
            self._show_help(parser, display_options=0, commands=[cmd_class])
            return

if (hasattr(cmd_class, 'help_options') and
            isinstance(cmd_class.help_options, list)):
            help_option_found=0
            for (help_option, short, desc, func) in cmd_class.help_options:
                if hasattr(opts, parser.get_attr_name(help_option)):
                    help_option_found=1
                    if hasattr(func, '__call__'):
                        func()
                    else:
                        raise DistutilsClassError(
                            "invalid help function %r for help option '%s': "
                            "must be a callable object (function, etc.)"
                            % (func, help_option))

if help_option_found:
                return

# Put the options from the command-line into their official
        # holding pen, the 'command_options' dictionary.
        opt_dict = self.get_option_dict(command)
        for (name, value) in vars(opts).items():
            opt_dict[name] = ("command line", value)

return args

def finalize_options(self):
        """Set final values for all the options on the Distribution
        instance, analogous to the .finalize_options() method of Command
        objects.
        """
        for attr in ('keywords', 'platforms'):
            value = getattr(self.metadata, attr)
            if value is None:
                continue
            if isinstance(value, str):
                value = [elm.strip() for elm in value.split(',')]
                setattr(self.metadata, attr, value)

def _show_help(self, parser, global_options=1, display_options=1,
                   commands=[]):
        """Show help for the setup script command-line in the form of
        several lists of command-line options.  'parser' should be a
        FancyGetopt instance; do not expect it to be returned in the
        same state, as its option table will be reset to make it
        generate the correct help text.

if global_options:
            if display_options:
                options = self._get_toplevel_options()
            else:
                options = self.global_options
            parser.set_option_table(options)
            parser.print_help(self.common_usage + "\nGlobal options:")
            print('')

if display_options:
            parser.set_option_table(self.display_options)
            parser.print_help(
                "Information display options (just display " +
                "information, ignore any commands)")
            print('')

for command in self.commands:
            if isinstance(command, type) and issubclass(command, Command):
                klass = command
            else:
                klass = self.get_command_class(command)
            if (hasattr(klass, 'help_options') and
                isinstance(klass.help_options, list)):
                parser.set_option_table(klass.user_options +
                                        fix_help_options(klass.help_options))
            else:
                parser.set_option_table(klass.user_options)
            parser.print_help("Options for '%s' command:" % klass.__name__)
            print('')

print(gen_usage(self.script_name))

def handle_display_options(self, option_order):
        """If there were any non-global "display-only" options
        (--help-commands or the metadata display options) on the command
        line, display the requested info and return true; else return
        false.
        """
        from distutils.core import gen_usage

# User just wants a list of commands -- we'll print it out and stop
        # processing now (ie. if they ran "setup --help-commands foo bar",
        # we ignore "foo bar").
        if self.help_commands:
            self.print_commands()
            print('')
            print(gen_usage(self.script_name))
            return 1

# If user supplied any of the "display metadata" options, then
        # display that metadata in the order in which the user supplied the
        # metadata options.
        any_display_options = 0
        is_display_option = {}
        for option in self.display_options:
            is_display_option[option[0]] = 1

for (opt, val) in option_order:
            if val and is_display_option.get(opt):
                opt = translate_longopt(opt)
                value = getattr(self.metadata, "get_"+opt)()
                if opt in ['keywords', 'platforms']:
                    print(','.join(value))
                elif opt in ('classifiers', 'provides', 'requires',
                             'obsoletes'):
                    print('\n'.join(value))
                else:
                    print(value)
                any_display_options = 1

return any_display_options

def print_command_list(self, commands, header, max_length):
        """Print a subset of the list of all commands -- used by
        'print_commands()'.
        """
        print(header + ":")

for cmd in commands:
            klass = self.cmdclass.get(cmd)
            if not klass:
                klass = self.get_command_class(cmd)
            try:
                description = klass.description
            except AttributeError:
                description = "(no description available)"

print("  %-*s  %s" % (max_length, cmd, description))

def print_commands(self):
        """Print out a help message listing all available commands with a
        description of each.  The list is divided into "standard commands"
        (listed in distutils.command.__all__) and "extra commands"
        (mentioned in self.cmdclass, but not a standard command).  The
        descriptions come from the command class attribute
        'description'.
        """
        import distutils.command
        std_commands = distutils.command.__all__
        is_std = {}
        for cmd in std_commands:
            is_std[cmd] = 1

extra_commands = []
        for cmd in self.cmdclass.keys():
            if not is_std.get(cmd):
                extra_commands.append(cmd)

max_length = 0
        for cmd in (std_commands + extra_commands):
            if len(cmd) > max_length:
                max_length = len(cmd)

self.print_command_list(std_commands,
                                "Standard commands",
                                max_length)
        if extra_commands:
            print
            self.print_command_list(extra_commands,
                                    "Extra commands",
                                    max_length)

def get_command_list(self):
        """Get a list of (command, description) tuples.
        The list is divided into "standard commands" (listed in
        distutils.command.__all__) and "extra commands" (mentioned in
        self.cmdclass, but not a standard command).  The descriptions come
        from the command class attribute 'description'.
        """
        # Currently this is only used on Mac OS, for the Mac-only GUI
        # Distutils interface (by Jack Jansen)

import distutils.command
        std_commands = distutils.command.__all__
        is_std = {}
        for cmd in std_commands:
            is_std[cmd] = 1

extra_commands = []
        for cmd in self.cmdclass.keys():
            if not is_std.get(cmd):
                extra_commands.append(cmd)

rv = []
        for cmd in (std_commands + extra_commands):
            klass = self.cmdclass.get(cmd)
            if not klass:
                klass = self.get_command_class(cmd)
            try:
                description = klass.description
            except AttributeError:
                description = "(no description available)"
            rv.append((cmd, description))
        return rv

# -- Command class/object methods ----------------------------------

def get_command_packages(self):
        """Return a list of packages from which commands are loaded."""
        pkgs = self.command_packages
        if not isinstance(pkgs, list):
            if pkgs is None:
                pkgs = ''
            pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
            if "distutils.command" not in pkgs:
                pkgs.insert(0, "distutils.command")
            self.command_packages = pkgs
        return pkgs

def get_command_class(self, command):
        """Return the class that implements the Distutils command named by
        'command'.  First we check the 'cmdclass' dictionary; if the
        command is mentioned there, we fetch the class object from the
        dictionary and return it.  Otherwise we load the command module
        ("distutils.command." + command) and fetch the command class from
        the module.  The loaded class is also stored in 'cmdclass'
        to speed future calls to 'get_command_class()'.

Raises DistutilsModuleError if the expected module could not be
        found, or if that module does not define the expected class.
        """
        klass = self.cmdclass.get(command)
        if klass:
            return klass

for pkgname in self.get_command_packages():
            module_name = "%s.%s" % (pkgname, command)
            klass_name = command

try:
                __import__ (module_name)
                module = sys.modules[module_name]
            except ImportError:
                continue

try:
                klass = getattr(module, klass_name)
            except AttributeError:
                raise DistutilsModuleError, \
                      "invalid command '%s' (no class '%s' in module '%s')" \
                      % (command, klass_name, module_name)

self.cmdclass[command] = klass
            return klass

raise DistutilsModuleError("invalid command '%s'" % command)

def get_command_obj(self, command, create=1):
        """Return the command object for 'command'.  Normally this object
        is cached on a previous call to 'get_command_obj()'; if no command
        object for 'command' is in the cache, then we either create and
        return it (if 'create' is true) or return None.
        """
        cmd_obj = self.command_obj.get(command)
        if not cmd_obj and create:
            if DEBUG:
                self.announce("Distribution.get_command_obj(): " \
                              "creating '%s' command object" % command)

klass = self.get_command_class(command)
            cmd_obj = self.command_obj[command] = klass(self)
            self.have_run[command] = 0

# Set any options that were supplied in config files
            # or on the command line.  (NB. support for error
            # reporting is lame here: any errors aren't reported
            # until 'finalize_options()' is called, which means
            # we won't report the source of the error.)
            options = self.command_options.get(command)
            if options:
                self._set_command_options(cmd_obj, options)

return cmd_obj

def _set_command_options(self, command_obj, option_dict=None):
        """Set the options for 'command_obj' from 'option_dict'.  Basically
        this means copying elements of a dictionary ('option_dict') to
        attributes of an instance ('command').

'command_obj' must be a Command instance.  If 'option_dict' is not
        supplied, uses the standard option dictionary for this command
        (from 'self.command_options').
        """
        command_name = command_obj.get_command_name()
        if option_dict is None:
            option_dict = self.get_option_dict(command_name)

if DEBUG:
            self.announce("  setting options for '%s' command:" % command_name)
        for (option, (source, value)) in option_dict.items():
            if DEBUG:
                self.announce("    %s = %s (from %s)" % (option, value,
                                                         source))
            try:
                bool_opts = map(translate_longopt, command_obj.boolean_options)
            except AttributeError:
                bool_opts = []
            try:
                neg_opt = command_obj.negative_opt
            except AttributeError:
                neg_opt = {}

try:
                is_string = isinstance(value, str)
                if option in neg_opt and is_string:
                    setattr(command_obj, neg_opt[option], not strtobool(value))
                elif option in bool_opts and is_string:
                    setattr(command_obj, option, strtobool(value))
                elif hasattr(command_obj, option):
                    setattr(command_obj, option, value)
                else:
                    raise DistutilsOptionError, \
                          ("error in %s: command '%s' has no such option '%s'"
                           % (source, command_name, option))
            except ValueError, msg:
                raise DistutilsOptionError, msg

def reinitialize_command(self, command, reinit_subcommands=0):
        """Reinitializes a command to the state it was in when first
        returned by 'get_command_obj()': ie., initialized but not yet
        finalized.  This provides the opportunity to sneak option
        values in programmatically, overriding or supplementing
        user-supplied values from the config files and command line.
        You'll have to re-finalize the command object (by calling
        'finalize_options()' or 'ensure_finalized()') before using it for
        real.

'command' should be a command name (string) or command object.  If
        'reinit_subcommands' is true, also reinitializes the command's
        sub-commands, as declared by the 'sub_commands' class attribute (if
        it has one).  See the "install" command for an example.  Only
        reinitializes the sub-commands that actually matter, ie. those
        whose test predicates return true.

Returns the reinitialized command object.
        """
        from distutils.cmd import Command
        if not isinstance(command, Command):
            command_name = command
            command = self.get_command_obj(command_name)
        else:
            command_name = command.get_command_name()

if not command.finalized:
            return command
        command.initialize_options()
        command.finalized = 0
        self.have_run[command_name] = 0
        self._set_command_options(command)

if reinit_subcommands:
            for sub in command.get_sub_commands():
                self.reinitialize_command(sub, reinit_subcommands)

return command

# -- Methods that operate on the Distribution ----------------------

def announce(self, msg, level=log.INFO):
        log.log(level, msg)

def run_commands(self):
        """Run each command that was seen on the setup script command line.
        Uses the list of commands found and cache of command objects
        created by 'get_command_obj()'.
        """
        for cmd in self.commands:
            self.run_command(cmd)

# -- Methods that operate on its Commands --------------------------

def run_command(self, command):
        """Do whatever it takes to run a command (including nothing at all,
        if the command has already been run).  Specifically: if we have
        already created and run the command named by 'command', return
        silently without doing anything.  If the command named by 'command'
        doesn't even have a command object yet, create one.  Then invoke
        'run()' on that command object (or an existing one).
        """
        # Already been here, done that? then return silently.
        if self.have_run.get(command):
            return

log.info("running %s", command)
        cmd_obj = self.get_command_obj(command)
        cmd_obj.ensure_finalized()
        cmd_obj.run()
        self.have_run[command] = 1

# -- Distribution query methods ------------------------------------

def has_pure_modules(self):
        return len(self.packages or self.py_modules or []) > 0

def has_ext_modules(self):
        return self.ext_modules and len(self.ext_modules) > 0

def has_c_libraries(self):
        return self.libraries and len(self.libraries) > 0

def has_modules(self):
        return self.has_pure_modules() or self.has_ext_modules()

def has_headers(self):
        return self.headers and len(self.headers) > 0

def has_scripts(self):
        return self.scripts and len(self.scripts) > 0

def has_data_files(self):
        return self.data_files and len(self.data_files) > 0

def is_pure(self):
        return (self.has_pure_modules() and
                not self.has_ext_modules() and
                not self.has_c_libraries())

# -- Metadata query methods ----------------------------------------

# If you're looking for 'get_name()', 'get_version()', and so forth,
    # they are defined in a sneaky way: the constructor binds self.get_XXX
    # to self.metadata.get_XXX.  The actual code is in the
    # DistributionMetadata class, below.

class DistributionMetadata:
    """Dummy class to hold the distribution meta-data: name, version,
    author, and so forth.
    """

_METHOD_BASENAMES = ("name", "version", "author", "author_email",
                         "maintainer", "maintainer_email", "url",
                         "license", "description", "long_description",
                         "keywords", "platforms", "fullname", "contact",
                         "contact_email", "license", "classifiers",
                         "download_url",
                         # PEP 314
                         "provides", "requires", "obsoletes",
                         )

def __init__(self, path=None):
        if path is not None:
            self.read_pkg_file(open(path))
        else:
            self.name = None
            self.version = None
            self.author = None
            self.author_email = None
            self.maintainer = None
            self.maintainer_email = None
            self.url = None
            self.license = None
            self.description = None
            self.long_description = None
            self.keywords = None
            self.platforms = None
            self.classifiers = None
            self.download_url = None
            # PEP 314
            self.provides = None
            self.requires = None
            self.obsoletes = None

def read_pkg_file(self, file):
        """Reads the metadata values from a file object."""
        msg = message_from_file(file)

def _read_field(name):
            value = msg[name]
            if value == 'UNKNOWN':
                return None
            return value

def _read_list(name):
            values = msg.get_all(name, None)
            if values == []:
                return None
            return values

metadata_version = msg['metadata-version']
        self.name = _read_field('name')
        self.version = _read_field('version')
        self.description = _read_field('summary')
        # we are filling author only.
        self.author = _read_field('author')
        self.maintainer = None
        self.author_email = _read_field('author-email')
        self.maintainer_email = None
        self.url = _read_field('home-page')
        self.license = _read_field('license')

if 'download-url' in msg:
            self.download_url = _read_field('download-url')
        else:
            self.download_url = None

self.long_description = _read_field('description')
        self.description = _read_field('summary')

if 'keywords' in msg:
            self.keywords = _read_field('keywords').split(',')

self.platforms = _read_list('platform')
        self.classifiers = _read_list('classifier')

# PEP 314 - these fields only exist in 1.1
        if metadata_version == '1.1':
            self.requires = _read_list('requires')
            self.provides = _read_list('provides')
            self.obsoletes = _read_list('obsoletes')
        else:
            self.requires = None
            self.provides = None
            self.obsoletes = None

def write_pkg_info(self, base_dir):
        """Write the PKG-INFO file into the release tree.
        """
        pkg_info = open(os.path.join(base_dir, 'PKG-INFO'), 'w')
        try:
            self.write_pkg_file(pkg_info)
        finally:
            pkg_info.close()

def write_pkg_file(self, file):
        """Write the PKG-INFO format data to a file object.
        """
        version = '1.0'
        if (self.provides or self.requires or self.obsoletes or
            self.classifiers or self.download_url):
            version = '1.1'

self._write_field(file, 'Metadata-Version', version)
        self._write_field(file, 'Name', self.get_name())
        self._write_field(file, 'Version', self.get_version())
        self._write_field(file, 'Summary', self.get_description())
        self._write_field(file, 'Home-page', self.get_url())
        self._write_field(file, 'Author', self.get_contact())
        self._write_field(file, 'Author-email', self.get_contact_email())
        self._write_field(file, 'License', self.get_license())
        if self.download_url:
            self._write_field(file, 'Download-URL', self.download_url)

long_desc = rfc822_escape(self.get_long_description())
        self._write_field(file, 'Description', long_desc)

keywords = ','.join(self.get_keywords())
        if keywords:
            self._write_field(file, 'Keywords', keywords)

self._write_list(file, 'Platform', self.get_platforms())
        self._write_list(file, 'Classifier', self.get_classifiers())

# PEP 314
        self._write_list(file, 'Requires', self.get_requires())
        self._write_list(file, 'Provides', self.get_provides())
        self._write_list(file, 'Obsoletes', self.get_obsoletes())

def _write_field(self, file, name, value):
        file.write('%s: %s\n' % (name, self._encode_field(value)))

def _write_list (self, file, name, values):
        for value in values:
            self._write_field(file, name, value)

def _encode_field(self, value):
        if value is None:
            return None
        if isinstance(value, unicode):
            return value.encode(PKG_INFO_ENCODING)
        return str(value)

# -- Metadata query methods ----------------------------------------

def get_name(self):
        return self.name or "UNKNOWN"

def get_version(self):
        return self.version or "0.0.0"

def get_fullname(self):
        return "%s-%s" % (self.get_name(), self.get_version())

def get_author(self):
        return self._encode_field(self.author) or "UNKNOWN"

def get_author_email(self):
        return self.author_email or "UNKNOWN"

def get_maintainer(self):
        return self._encode_field(self.maintainer) or "UNKNOWN"

def get_maintainer_email(self):
        return self.maintainer_email or "UNKNOWN"

def get_contact(self):
        return (self._encode_field(self.maintainer) or
                self._encode_field(self.author) or "UNKNOWN")

def get_contact_email(self):
        return self.maintainer_email or self.author_email or "UNKNOWN"

def get_url(self):
        return self.url or "UNKNOWN"

def get_license(self):
        return self.license or "UNKNOWN"
    get_licence = get_license

def get_description(self):
        return self._encode_field(self.description) or "UNKNOWN"

def get_long_description(self):
        return self._encode_field(self.long_description) or "UNKNOWN"

def get_keywords(self):
        return self.keywords or []

def get_platforms(self):
        return self.platforms or ["UNKNOWN"]

def get_classifiers(self):
        return self.classifiers or []

def get_download_url(self):
        return self.download_url or "UNKNOWN"

# PEP 314
    def get_requires(self):
        return self.requires or []

def set_requires(self, value):
        import distutils.versionpredicate
        for v in value:
            distutils.versionpredicate.VersionPredicate(v)
        self.requires = value

def get_provides(self):
        return self.provides or []

def set_provides(self, value):
        value = [v.strip() for v in value]
        for v in value:
            import distutils.versionpredicate
            distutils.versionpredicate.split_provision(v)
        self.provides = value

def get_obsoletes(self):
        return self.obsoletes or []

def set_obsoletes(self, value):
        import distutils.versionpredicate
        for v in value:
            distutils.versionpredicate.VersionPredicate(v)
        self.obsoletes = value

def fix_help_options(options):
    """Convert a 4-tuple 'help_options' list as found in various command
    classes to the 3-tuple form required by FancyGetopt.
    """
    new_options = []
    for help_tuple in options:
        new_options.append(help_tuple[0:3])
    return new_options
dist.pyc000064400000114410151702014350006223 0ustar00�
{fc@s&dZdZddlZddlZddlZddlmZyddlZWnek
rie	ZnXddl
mZmZm
Z
mZddlmZmZddlmZmZmZddlmZdd	lmZd
Zejd�Zdfd
��YZdfd��YZd�ZdS(s}distutils.dist

Provides the Distribution class, which represents the module distribution
being built/installed/distributed.
s$Id$i����N(tmessage_from_file(tDistutilsOptionErrortDistutilsArgErrortDistutilsModuleErrortDistutilsClassError(tFancyGetoptttranslate_longopt(t
check_environt	strtoboolt
rfc822_escape(tlog(tDEBUGsutf-8s^[a-zA-Z]([a-zA-Z0-9_]*)$tDistributioncBs�eZdZd]d^d_d`dbgZdZdcdddedfdgdhdidjdkdldmdndodpdqdrdsdtdudvdwgZed<�e�Zidd6Z	dad=�Z
d>�Zdadad?d@�ZdA�Z
dadB�ZdC�ZdD�ZdE�ZdF�ZddgdG�ZdH�ZdI�ZdJ�ZdK�ZdL�ZdM�ZddN�ZdadO�ZdPdQ�ZejdR�ZdS�Z dT�Z!dU�Z"dV�Z#dW�Z$dX�Z%dY�Z&dZ�Z'd[�Z(d\�Z)RS(xs�The core of the Distutils.  Most of the work hiding behind 'setup'
    is really done within a Distribution instance, which farms the work out
    to the Distutils commands specified on the command line.

Setup scripts will almost never instantiate Distribution directly,
    unless the 'setup()' function is totally inadequate to their needs.
    However, it is conceivable that a setup script might wish to subclass
    Distribution for some specialized purpose, and then pass the subclass
    to 'setup()' as the 'distclass' keyword argument.  If so, it is
    necessary to respect the expectations that 'setup' has of Distribution.
    See the code for 'setup()', in core.py, for details.
    tverbosetvsrun verbosely (default)itquiettqs!run quietly (turns verbosity off)sdry-runtnsdon't actually do anythingthelpthsshow detailed help messagesno-user-cfgs-ignore pydistutils.cfg in your home directorys�Common commands: (see '--help-commands' for more)

setup.py build      will build the package underneath 'build/'
  setup.py install    will install the package
s
help-commandsslist all available commandstnamesprint package nametversiontVsprint package versiontfullnamesprint <package name>-<version>tauthorsprint the author's namesauthor-emails print the author's email addresst
maintainersprint the maintainer's namesmaintainer-emails$print the maintainer's email addresstcontacts7print the maintainer's name if known, else the author'ss
contact-emails@print the maintainer's email address if known, else the author'sturlsprint the URL for this packagetlicenses print the license of the packagetlicencesalias for --licensetdescriptionsprint the package descriptionslong-descriptions"print the long package descriptiont	platformssprint the list of platformstclassifierssprint the list of classifierstkeywordssprint the list of keywordstprovidess+print the list of packages/modules providedtrequiress+print the list of packages/modules requiredt	obsoletess0print the list of packages/modules made obsoletecCst|d�S(Ni(R(tx((s&/usr/lib64/python2.7/distutils/dist.pyt<lambda>wtcCsid|_d|_d|_x!|jD]}t||d�q%Wt�|_x:|jjD],}d|}t||t|j|��qXWi|_	d|_d|_d|_
i|_g|_d|_i|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_d|_i|_i|_|r|jd�}|dk	r�|d=xY|j �D]H\}}|j!|�}x*|j �D]\}	}
d|
f||	<q�WqzWnd|kr#|d|d<|d=d	}t"dk	rt"j#|�q#t$j%j&|d
�nx�|j �D]�\}}
t'|jd|�rot|jd|�|
�q0t'|j|�r�t|j||
�q0t'||�r�t|||
�q0dt(|�}t"dk	r�t"j#|�q0t$j%j&|d
�q0Wnt)|_*|j
dk	r[x@|j
D]2}
|
j+d
�s;Pn|
dkr"t,|_*Pq"q"Wn|j-�dS(s0Construct a new Distribution instance: initialize all the
        attributes of a Distribution, and then use 'attrs' (a dictionary
        mapping attribute names to values) to assign some of those
        attributes their "real" values.  (Any attributes not mentioned in
        'attrs' will be assigned to some null value: 0, None, an empty list
        or dictionary, etc.)  Most importantly, initialize the
        'command_obj' attribute to the empty dictionary; this will be
        filled in with real command objects by 'parse_command_line()'.
        iitget_R'toptionsssetup scriptRRs:'licence' distribution option is deprecated; use 'license's
tset_sUnknown distribution option: %st-s
--no-user-cfgN(.R
tdry_runRtdisplay_option_namestsetattrtDistributionMetadatatmetadatat_METHOD_BASENAMEStgetattrtcmdclasstNonetcommand_packagestscript_nametscript_argstcommand_optionst
dist_filestpackagestpackage_datatpackage_dirt
py_modulest	librariestheaderstext_modulestext_packagetinclude_dirst
extra_pathtscriptst
data_filestpasswordtcommand_objthave_runtgettitemstget_option_dicttwarningstwarntsyststderrtwritethasattrtreprtTruet
want_user_cfgt
startswithtFalsetfinalize_options(tselftattrstattrtbasenametmethod_nameR)tcommandtcmd_optionstopt_dicttopttvaltmsgtkeytarg((s&/usr/lib64/python2.7/distutils/dist.pyt__init__�s�			
 																							cCs6|jj|�}|dkr2i}|j|<n|S(s�Get the option dictionary for a given command.  If that
        command's option dictionary hasn't been created yet, then create it
        and return the new dictionary; otherwise, return the existing
        option dictionary.
        N(R8RIR4(RXR]tdict((s&/usr/lib64/python2.7/distutils/dist.pyRK!sR'c	Csddlm}|dkr8|jj�}|j�n|dk	rb|j||�|d}n|s}|j|d�dSx�|D]�}|jj|�}|dkr�|j|d|�q�|j|d|�||�}x,|jd�D]}|j|d|�q�Wq�WdS(Ni����(tpformats  sno commands known yetsno option dict for '%s' commandsoption dict for '%s' command:s
(	tpprintRgR4R8tkeystsorttannounceRItsplit(	RXtheadertcommandstindentRgtcmd_nameR_touttline((s&/usr/lib64/python2.7/distutils/dist.pytdump_option_dicts,s(

cCsg}t�tjjtjdj�}tjj|d�}tjj|�r`|j	|�ntj
dkrxd}nd}|jr�tjjtjjd�|�}tjj|�r�|j	|�q�nd}tjj|�r�|j	|�nt
r|jdd	j|��n|S(
s�Find as many configuration files as should be processed for this
        platform, and return a list of filenames in the order in which they
        should be parsed.  The filenames returned are guaranteed to exist
        (modulo nasty race conditions).

The file in the user's home directory can be disabled with the
        --no-user-cfg option.
        t	distutilss
distutils.cfgtposixs.pydistutils.cfgspydistutils.cfgt~s	setup.cfgsusing config files: %ss, (RtostpathtdirnameRNtmodulest__file__tjointisfiletappendRRTt
expanduserRRk(RXtfilestsys_dirtsys_filet
user_filenamet	user_filet
local_file((s&/usr/lib64/python2.7/distutils/dist.pytfind_config_filesIs&		!c
Cs�ddlm}|dkr+|j�}ntrA|jd�n|�}x�|D]�}trq|jd|�n|j|�x�|j�D]x}|j|�}|j|�}xQ|D]I}|dkr�|j	||�}	|j
dd�}||	f||<q�q�Wq�W|j�qQWd|jkr�x�|jdj
�D]�\}\}
}	|jj	|�}yY|rt||t|	��n5|dkr�t||t|	��nt|||	�Wq8tk
r�}t|�q8Xq8WndS(Ni����(tConfigParsers"Distribution.parse_config_files():s  reading %st__name__R+t_tglobalR
R,(R
R,(R�R4R�RRktreadtsectionsR)RKRItreplaceReR8RJtnegative_optR.Rt
ValueErrorR(
RXt	filenamesR�tparsertfilenametsectionR)R_R`RatsrctaliasRb((s&/usr/lib64/python2.7/distutils/dist.pytparse_config_filesys<

&cCs|j�}g|_t||j�}|j|j�|jidd6�|jd|jd|�}|j	�}t
j|j�|j
|�r�dSx,|r�|j||�}|dkr�dSq�W|jr�|j|dt|j�dkd|j�dS|jstd	�nd
S(s�Parse the setup script's command line, taken from the
        'script_args' instance attribute (which defaults to 'sys.argv[1:]'
        -- see 'setup()' in core.py).  This list is first processed for
        "global options" -- options that set attributes of the Distribution
        instance.  Then, it is alternately scanned for Distutils commands
        and options for that command.  Each new command terminates the
        options for the previous command.  The allowed options for a
        command are determined by the 'user_options' attribute of the
        command class -- thus, we have to be able to load command classes
        in order to parse the command line.  Any error in that 'options'
        attribute raises DistutilsGetoptError; any error on the
        command-line raises DistutilsArgError.  If no Distutils commands
        were found on the command line, raises DistutilsArgError.  Return
        true if command-line was successfully parsed and we should carry
        on with executing commands; false if no errors but we shouldn't
        execute commands (currently, this only happens if user asks for
        help).
        RRtargstobjectNtdisplay_optionsiRnsno commands suppliedi(t_get_toplevel_optionsRnRR�tset_negative_aliasesR�tset_aliasestgetoptR7tget_option_orderR
t
set_verbosityR
thandle_display_optionst_parse_command_optsR4Rt
_show_helptlenR(RXttoplevel_optionsR�R�toption_order((s&/usr/lib64/python2.7/distutils/dist.pytparse_command_line�s,				
	cCs|jdgS(s�Return the non-display options recognized at the top level.

This includes options that are recognized *only* at the top
        level as well as options recognized for commands.
        scommand-packages=s0list of packages that provide distutils commandsN(scommand-packages=Ns0list of packages that provide distutils commands(tglobal_optionsR4(RX((s&/usr/lib64/python2.7/distutils/dist.pyR��scCs�ddlm}|d}tj|�s9td|�n|jj|�y|j|�}Wntk
rz}t	|�nXt
||�s�td|�nt|d�o�t
|jt�s�tdd|�n|j}t|d	�r|j�}|j|j�nt|d
�r9t
|jt�r9t|j�}ng}|j|j|j|�|j|�|j|d�\}}	t|	d�r�|	jr�|j|d
dd|g�dSt|d
�r\t
|jt�r\d}
xm|jD]b\}}}
}t|	|j|��r�d}
t|d�r2|�qKtd||f��q�q�W|
r\dSn|j|�}x0t|	�j�D]\}}d|f||<q~W|S(s�Parse the command-line options for a single command.
        'parser' must be a FancyGetopt instance; 'args' must be the list
        of arguments, starting with the current command (whose options
        we are about to parse).  Returns a new version of 'args' with
        the next command at the front of the list; will be the empty
        list if there are no more commands on the command line.  Returns
        None if the user asked for help on this command.
        i����(tCommandisinvalid command name '%s's&command class %s must subclass Commandtuser_optionsscommand class %s must provide s+'user_options' attribute (a list of tuples)R�thelp_optionsiRR�RnNt__call__sYinvalid help function %r for help option '%s': must be a callable object (function, etc.)scommand line(t
distutils.cmdR�t
command_retmatcht
SystemExitRnR~tget_command_classRRt
issubclassRRQt
isinstanceR�tlistR�tcopytupdateR�tfix_help_optionstset_option_tableR�R�R�RR�t
get_attr_nameRKtvarsRJ(RXR�R�R�R]t	cmd_classRbR�R�toptsthelp_option_foundthelp_optiontshorttdesctfuncR_Rtvalue((s&/usr/lib64/python2.7/distutils/dist.pyR��sf

cCs�xdD]w}t|j|�}|dkr1qnt|t�rg|jd�D]}|j�^qP}t|j||�qqWdS(s�Set final values for all the options on the Distribution
        instance, analogous to the .finalize_options() method of Command
        objects.
        R!Rt,N(R!R(R2R0R4R�tstrRltstripR.(RXRZR�telm((s&/usr/lib64/python2.7/distutils/dist.pyRWRs
(c
Csbddlm}ddlm}|rm|r;|j�}n	|j}|j|�|j|jd�dGHn|r�|j|j	�|jdd�dGHnx�|j
D]�}t|t�r�t
||�r�|}	n|j|�}	t|	d�r#t|	jt�r#|j|	jt|	j��n|j|	j�|jd	|	j�dGHq�W||j�GHd
S(sbShow help for the setup script command-line in the form of
        several lists of command-line options.  'parser' should be a
        FancyGetopt instance; do not expect it to be returned in the
        same state, as its option table will be reset to make it
        generate the correct help text.

If 'global_options' is true, lists the global options:
        --verbose, --dry-run, etc.  If 'display_options' is true, lists
        the "display-only" options: --name, --version, etc.  Finally,
        lists per-command help for every command name or command class
        in 'commands'.
        i����(t	gen_usage(R�s
Global options:R's*Information display options (just display s!information, ignore any commands)R�sOptions for '%s' command:N(tdistutils.coreR�R�R�R�R�R�t
print_helptcommon_usageR�RnR�ttypeR�R�RQR�R�R�R�R�R6(
RXR�R�R�RnR�R�R)R]tklass((s&/usr/lib64/python2.7/distutils/dist.pyR�_s6	
		c	Csddlm}|jr:|j�dGH||j�GHdSd}i}x|jD]}d||d<qPWx�|D]�\}}|ro|j|�rot|�}t|j	d|��}|dkr�d	j
|�GHn"|dkr�dj
|�GHn|GHd}qoqoW|S(s�If there were any non-global "display-only" options
        (--help-commands or the metadata display options) on the command
        line, display the requested info and return true; else return
        false.
        i����(R�R'iiR(R!RR�R R"R#R$s
(R!R(R R"R#R$(R�R�t
help_commandstprint_commandsR6R�RIRR2R0R|(	RXR�R�tany_display_optionstis_display_optiontoptionR`RaR�((s&/usr/lib64/python2.7/distutils/dist.pyR��s,	
	
cCs�|dGHxq|D]i}|jj|�}|s@|j|�}ny
|j}Wntk
rfd}nXd|||fGHqWdS(sZPrint a subset of the list of all commands -- used by
        'print_commands()'.
        t:s(no description available)s
  %-*s  %sN(R3RIR�RtAttributeError(RXRnRmt
max_lengthtcmdR�R((s&/usr/lib64/python2.7/distutils/dist.pytprint_command_list�s

cCs�ddl}|jj}i}x|D]}d||<q%Wg}x6|jj�D]%}|j|�sO|j|�qOqOWd}x3||D]'}t|�|kr�t|�}q�q�W|j|d|�|r�H|j|d|�ndS(snPrint out a help message listing all available commands with a
        description of each.  The list is divided into "standard commands"
        (listed in distutils.command.__all__) and "extra commands"
        (mentioned in self.cmdclass, but not a standard command).  The
        descriptions come from the command class attribute
        'description'.
        i����NiisStandard commandssExtra commands(	tdistutils.commandR]t__all__R3RiRIR~R�R�(RXRttstd_commandstis_stdR�textra_commandsR�((s&/usr/lib64/python2.7/distutils/dist.pyR��s*
		c	Cs�ddl}|jj}i}x|D]}d||<q%Wg}x6|jj�D]%}|j|�sO|j|�qOqOWg}xv||D]j}|jj|�}|s�|j|�}ny
|j}Wnt	k
r�d}nX|j||f�q�W|S(s>Get a list of (command, description) tuples.
        The list is divided into "standard commands" (listed in
        distutils.command.__all__) and "extra commands" (mentioned in
        self.cmdclass, but not a standard command).  The descriptions come
        from the command class attribute 'description'.
        i����Nis(no description available)(
R�R]R�R3RiRIR~R�RR�(	RXRtR�R�R�R�trvR�R((s&/usr/lib64/python2.7/distutils/dist.pytget_command_list�s(

cCs�|j}t|t�s�|dkr-d}ng|jd�D]}|dkr=|j�^q=}d|kr�|jdd�n||_n|S(s9Return a list of packages from which commands are loaded.R'R�sdistutils.commandiN(R5R�R�R4RlR�tinsert(RXtpkgstpkg((s&/usr/lib64/python2.7/distutils/dist.pytget_command_packagess		4cCs�|jj|�}|r|Sx�|j�D]�}d||f}|}yt|�tj|}Wntk
rvq)nXyt||�}Wn'tk
r�t	d|||f�nX||j|<|SWt	d|��dS(soReturn the class that implements the Distutils command named by
        'command'.  First we check the 'cmdclass' dictionary; if the
        command is mentioned there, we fetch the class object from the
        dictionary and return it.  Otherwise we load the command module
        ("distutils.command." + command) and fetch the command class from
        the module.  The loaded class is also stored in 'cmdclass'
        to speed future calls to 'get_command_class()'.

Raises DistutilsModuleError if the expected module could not be
        found, or if that module does not define the expected class.
        s%s.%ss3invalid command '%s' (no class '%s' in module '%s')sinvalid command '%s'N(
R3RIR�t
__import__RNRztImportErrorR2R�R(RXR]R�tpkgnametmodule_namet
klass_nametmodule((s&/usr/lib64/python2.7/distutils/dist.pyR�s(

cCs�|jj|�}|r�|r�tr9|jd|�n|j|�}||�}|j|<d|j|<|jj|�}|r�|j||�q�n|S(sReturn the command object for 'command'.  Normally this object
        is cached on a previous call to 'get_command_obj()'; if no command
        object for 'command' is in the cache, then we either create and
        return it (if 'create' is true) or return None.
        s<Distribution.get_command_obj(): creating '%s' command objecti(RGRIRRkR�RHR8t_set_command_options(RXR]tcreatetcmd_objR�R)((s&/usr/lib64/python2.7/distutils/dist.pytget_command_objAs
	
cCs�|j�}|dkr*|j|�}ntrD|jd|�nx_|j�D]Q\}\}}tr�|jd|||f�nytt|j�}Wnt	k
r�g}nXy
|j
}Wnt	k
r�i}nXy�t|t�}	||kr|	rt
|||t|��nc||krJ|	rJt
||t|��n8t||�rlt
|||�ntd|||f�WqQtk
r�}
t|
�qQXqQWdS(sySet the options for 'command_obj' from 'option_dict'.  Basically
        this means copying elements of a dictionary ('option_dict') to
        attributes of an instance ('command').

'command_obj' must be a Command instance.  If 'option_dict' is not
        supplied, uses the standard option dictionary for this command
        (from 'self.command_options').
        s#  setting options for '%s' command:s    %s = %s (from %s)s1error in %s: command '%s' has no such option '%s'N(tget_command_nameR4RKRRkRJtmapRtboolean_optionsR�R�R�R�R.RRQRR�(RXRGtoption_dicttcommand_nameR�tsourceR�t	bool_optstneg_optt	is_stringRb((s&/usr/lib64/python2.7/distutils/dist.pyR�\s<

icCs�ddlm}t||�s7|}|j|�}n|j�}|jsP|S|j�d|_d|j|<|j|�|r�x'|j	�D]}|j
||�q�Wn|S(s�Reinitializes a command to the state it was in when first
        returned by 'get_command_obj()': ie., initialized but not yet
        finalized.  This provides the opportunity to sneak option
        values in programmatically, overriding or supplementing
        user-supplied values from the config files and command line.
        You'll have to re-finalize the command object (by calling
        'finalize_options()' or 'ensure_finalized()') before using it for
        real.

Returns the reinitialized command object.
        i����(R�i(R�R�R�R�R�t	finalizedtinitialize_optionsRHR�tget_sub_commandstreinitialize_command(RXR]treinit_subcommandsR�R�tsub((s&/usr/lib64/python2.7/distutils/dist.pyR��s

cCstj||�dS(N(R
(RXRbtlevel((s&/usr/lib64/python2.7/distutils/dist.pyRk�scCs%x|jD]}|j|�q
WdS(s�Run each command that was seen on the setup script command line.
        Uses the list of commands found and cache of command objects
        created by 'get_command_obj()'.
        N(Rntrun_command(RXR�((s&/usr/lib64/python2.7/distutils/dist.pytrun_commands�scCsZ|jj|�rdStjd|�|j|�}|j�|j�d|j|<dS(s�Do whatever it takes to run a command (including nothing at all,
        if the command has already been run).  Specifically: if we have
        already created and run the command named by 'command', return
        silently without doing anything.  If the command named by 'command'
        doesn't even have a command object yet, create one.  Then invoke
        'run()' on that command object (or an existing one).
        Ns
running %si(RHRIR
tinfoR�tensure_finalizedtrun(RXR]R�((s&/usr/lib64/python2.7/distutils/dist.pyR��s

cCs"t|jp|jpg�dkS(Ni(R�R:R=(RX((s&/usr/lib64/python2.7/distutils/dist.pythas_pure_modules�scCs|jot|j�dkS(Ni(R@R�(RX((s&/usr/lib64/python2.7/distutils/dist.pythas_ext_modules�scCs|jot|j�dkS(Ni(R>R�(RX((s&/usr/lib64/python2.7/distutils/dist.pythas_c_libraries�scCs|j�p|j�S(N(RR(RX((s&/usr/lib64/python2.7/distutils/dist.pythas_modules�scCs|jot|j�dkS(Ni(R?R�(RX((s&/usr/lib64/python2.7/distutils/dist.pythas_headers�scCs|jot|j�dkS(Ni(RDR�(RX((s&/usr/lib64/python2.7/distutils/dist.pythas_scripts�scCs|jot|j�dkS(Ni(RER�(RX((s&/usr/lib64/python2.7/distutils/dist.pythas_data_files�scCs$|j�o#|j�o#|j�S(N(RRR(RX((s&/usr/lib64/python2.7/distutils/dist.pytis_pure�s
(R
Rsrun verbosely (default)i(RRs!run quietly (turns verbosity off)(sdry-runRsdon't actually do anything(RRsshow detailed help messageN(sno-user-cfgNs-ignore pydistutils.cfg in your home directory(s
help-commandsNslist all available commands(RNsprint package name(RRsprint package version(RNsprint <package name>-<version>(RNsprint the author's name(sauthor-emailNs print the author's email address(RNsprint the maintainer's name(smaintainer-emailNs$print the maintainer's email address(RNs7print the maintainer's name if known, else the author's(s
contact-emailNs@print the maintainer's email address if known, else the author's(RNsprint the URL for this package(RNs print the license of the package(RNsalias for --license(RNsprint the package description(slong-descriptionNs"print the long package description(RNsprint the list of platforms(R Nsprint the list of classifiers(R!Nsprint the list of keywords(R"Ns+print the list of packages/modules provided(R#Ns+print the list of packages/modules required(R$Ns0print the list of packages/modules made obsolete(*R�t
__module__t__doc__R4R�R�R�R�R-R�ReRKRsR�R�R�R�R�RWR�R�R�R�R�R�R�R�R�R�R
tINFORkR�R�RRRRRRRR(((s&/usr/lib64/python2.7/distutils/dist.pyR"s�	
			
�		0.	C		]	
1	(		!	#		'+)	
								R/cBs+eZdZd3Zd4d�Zd�Zd�Zd�Zd�Z	d�Z
d�Zd�Zd�Z
d�Zd�Zd �Zd!�Zd"�Zd#�Zd$�Zd%�Zd&�ZeZd'�Zd(�Zd)�Zd*�Zd+�Zd,�Zd-�Zd.�Zd/�Z d0�Z!d1�Z"d2�Z#RS(5s]Dummy class to hold the distribution meta-data: name, version,
    author, and so forth.
    RRRtauthor_emailRtmaintainer_emailRRRtlong_descriptionR!RRRt
contact_emailR tdownload_urlR"R#R$cCs�|dk	r"|jt|��n�d|_d|_d|_d|_d|_d|_d|_	d|_
d|_d|_d|_
d|_d|_d|_d|_d|_d|_dS(N(R4t
read_pkg_filetopenRRRRRRRRRR
R!RR RR"R#R$(RXRx((s&/usr/lib64/python2.7/distutils/dist.pyRes&																cs�t|���fd�}�fd�}�d}|d�|_|d�|_|d�|_|d�|_d|_|d�|_d|_|d	�|_	|d
�|_
d�kr�|d�|_n	d|_|d�|_|d�|_d
�kr|d
�j
d�|_n|d�|_|d�|_|dkru|d�|_|d�|_|d�|_nd|_d|_d|_dS(s-Reads the metadata values from a file object.cs�|}|dkrdS|S(NtUNKNOWN(R4(RR�(Rb(s&/usr/lib64/python2.7/distutils/dist.pyt_read_fields
cs&�j|d�}|gkr"dS|S(N(tget_allR4(Rtvalues(Rb(s&/usr/lib64/python2.7/distutils/dist.pyt
_read_list#ssmetadata-versionRRtsummaryRsauthor-emails	home-pageRsdownload-urlRR!R�tplatformt
classifiers1.1R#R"R$N(RRRRRR4RRRRRRR
RlR!RR R#R"R$(RXtfileRRtmetadata_version((Rbs&/usr/lib64/python2.7/distutils/dist.pyRs:
					cCsAttjj|d�d�}z|j|�Wd|j�XdS(s7Write the PKG-INFO file into the release tree.
        sPKG-INFOtwN(RRwRxR|twrite_pkg_filetclose(RXtbase_dirtpkg_info((s&/usr/lib64/python2.7/distutils/dist.pytwrite_pkg_infoMscCs�d}|js3|js3|js3|js3|jr<d}n|j|d|�|j|d|j��|j|d|j��|j|d|j��|j|d|j	��|j|d|j
��|j|d	|j��|j|d
|j��|jr |j|d|j�nt
|j��}|j|d|�d
j|j��}|rv|j|d|�n|j|d|j��|j|d|j��|j|d|j��|j|d|j��|j|d|j��dS(s9Write the PKG-INFO format data to a file object.
        s1.0s1.1sMetadata-VersiontNametVersiontSummarys	Home-pagetAuthorsAuthor-emailtLicensesDownload-URLtDescriptionR�tKeywordstPlatformt
ClassifiertRequirestProvidest	ObsoletesN(R"R#R$R Rt_write_fieldtget_nametget_versiontget_descriptiontget_urltget_contacttget_contact_emailtget_licenseR	tget_long_descriptionR|tget_keywordst_write_listt
get_platformstget_classifierstget_requirestget_providest
get_obsoletes(RXRRt	long_descR!((s&/usr/lib64/python2.7/distutils/dist.pyRVs0		cCs$|jd||j|�f�dS(Ns%s: %s
(RPt
_encode_field(RXRRR�((s&/usr/lib64/python2.7/distutils/dist.pyR.xscCs(x!|D]}|j|||�qWdS(N(R.(RXRRRR�((s&/usr/lib64/python2.7/distutils/dist.pyR8{s
cCs6|dkrdSt|t�r,|jt�St|�S(N(R4R�tunicodetencodetPKG_INFO_ENCODINGR�(RXR�((s&/usr/lib64/python2.7/distutils/dist.pyR?s

cCs
|jpdS(NR(R(RX((s&/usr/lib64/python2.7/distutils/dist.pyR/�scCs
|jpdS(Ns0.0.0(R(RX((s&/usr/lib64/python2.7/distutils/dist.pyR0�scCsd|j�|j�fS(Ns%s-%s(R/R0(RX((s&/usr/lib64/python2.7/distutils/dist.pytget_fullname�scCs|j|j�pdS(NR(R?R(RX((s&/usr/lib64/python2.7/distutils/dist.pyt
get_author�scCs
|jpdS(NR(R(RX((s&/usr/lib64/python2.7/distutils/dist.pytget_author_email�scCs|j|j�pdS(NR(R?R(RX((s&/usr/lib64/python2.7/distutils/dist.pytget_maintainer�scCs
|jpdS(NR(R(RX((s&/usr/lib64/python2.7/distutils/dist.pytget_maintainer_email�scCs(|j|j�p'|j|j�p'dS(NR(R?RR(RX((s&/usr/lib64/python2.7/distutils/dist.pyR3�scCs|jp|jpdS(NR(RR(RX((s&/usr/lib64/python2.7/distutils/dist.pyR4�scCs
|jpdS(NR(R(RX((s&/usr/lib64/python2.7/distutils/dist.pyR2�scCs
|jpdS(NR(R(RX((s&/usr/lib64/python2.7/distutils/dist.pyR5�scCs|j|j�pdS(NR(R?R(RX((s&/usr/lib64/python2.7/distutils/dist.pyR1�scCs|j|j�pdS(NR(R?R
(RX((s&/usr/lib64/python2.7/distutils/dist.pyR6�scCs
|jpgS(N(R!(RX((s&/usr/lib64/python2.7/distutils/dist.pyR7�scCs|jpdgS(NR(R(RX((s&/usr/lib64/python2.7/distutils/dist.pyR9�scCs
|jpgS(N(R (RX((s&/usr/lib64/python2.7/distutils/dist.pyR:�scCs
|jpdS(NR(R(RX((s&/usr/lib64/python2.7/distutils/dist.pytget_download_url�scCs
|jpgS(N(R#(RX((s&/usr/lib64/python2.7/distutils/dist.pyR;�scCs:ddl}x|D]}|jj|�qW||_dS(Ni����(tdistutils.versionpredicatetversionpredicatetVersionPredicateR#(RXR�RtR((s&/usr/lib64/python2.7/distutils/dist.pytset_requires�s
cCs
|jpgS(N(R"(RX((s&/usr/lib64/python2.7/distutils/dist.pyR<�scCsYg|D]}|j�^q}x*|D]"}ddl}|jj|�q&W||_dS(Ni����(R�RIRJtsplit_provisionR"(RXR�RRt((s&/usr/lib64/python2.7/distutils/dist.pytset_provides�s

cCs
|jpgS(N(R$(RX((s&/usr/lib64/python2.7/distutils/dist.pyR=�scCs:ddl}x|D]}|jj|�qW||_dS(Ni����(RIRJRKR$(RXR�RtR((s&/usr/lib64/python2.7/distutils/dist.pyt
set_obsoletes�s
(RRRRRRRRRR
R!RRRRRR RR"R#R$N($R�RR	R1R4ReRR!RR.R8R?R/R0RCRDRERFRGR3R4R2R5tget_licenceR1R6R7R9R:RHR;RLR<RNR=RO(((s&/usr/lib64/python2.7/distutils/dist.pyR/�sN	4			"																										cCs/g}x"|D]}|j|dd!�q
W|S(sConvert a 4-tuple 'help_options' list as found in various command
    classes to the 3-tuple form required by FancyGetopt.
    ii(R~(R)tnew_optionst
help_tuple((s&/usr/lib64/python2.7/distutils/dist.pyR��s
( R	t__revision__RNRwtretemailRRLR�R4tdistutils.errorsRRRRtdistutils.fancy_getoptRRtdistutils.utilRRR	RtR
tdistutils.debugRRBtcompileR�RR/R�(((s&/usr/lib64/python2.7/distutils/dist.pyt<module>s($
"�����dist.pyo000064400000114410151702014350006237 0ustar00�
{fc@s&dZdZddlZddlZddlZddlmZyddlZWnek
rie	ZnXddl
mZmZm
Z
mZddlmZmZddlmZmZmZddlmZdd	lmZd
Zejd�Zdfd
��YZdfd��YZd�ZdS(s}distutils.dist

cCs
|jpgS(N(R$(RX((s&/usr/lib64/python2.7/distutils/dist.pyR=�scCs:ddl}x|D]}|jj|�qW||_dS(Ni����(RIRJRKR$(RXR�RtR((s&/usr/lib64/python2.7/distutils/dist.pyt
set_obsoletes�s
(RRRRRRRRRR
R!RRRRRR RR"R#R$N($R�RR	R1R4ReRR!RR.R8R?R/R0RCRDRERFRGR3R4R2R5tget_licenceR1R6R7R9R:RHR;RLR<RNR=RO(((s&/usr/lib64/python2.7/distutils/dist.pyR/�sN	4			"																										cCs/g}x"|D]}|j|dd!�q
W|S(sConvert a 4-tuple 'help_options' list as found in various command
    classes to the 3-tuple form required by FancyGetopt.
    ii(R~(R)tnew_optionst
help_tuple((s&/usr/lib64/python2.7/distutils/dist.pyR��s
( R	t__revision__RNRwtretemailRRLR�R4tdistutils.errorsRRRRtdistutils.fancy_getoptRRtdistutils.utilRRR	RtR
tdistutils.debugRRBtcompileR�RR/R�(((s&/usr/lib64/python2.7/distutils/dist.pyt<module>s($
"�����emxccompiler.py000064400000027233151702014350007612 0ustar00"""distutils.emxccompiler

Provides the EMXCCompiler class, a subclass of UnixCCompiler that
handles the EMX port of the GNU C compiler to OS/2.
"""

# issues:
#
# * OS/2 insists that DLLs can have names no longer than 8 characters
#   We put export_symbols in a def-file, as though the DLL can have
#   an arbitrary length name, but truncate the output filename.
#
# * only use OMF objects and use LINK386 as the linker (-Zomf)
#
# * always build for multithreading (-Zmt) as the accompanying OS/2 port
#   of Python is only distributed with threads enabled.
#
# tested configurations:
#
# * EMX gcc 2.81/EMX 0.9d fix03

__revision__ = "$Id$"

class EMXCCompiler (UnixCCompiler):

compiler_type = 'emx'
    obj_extension = ".obj"
    static_lib_extension = ".lib"
    shared_lib_extension = ".dll"
    static_lib_format = "%s%s"
    shared_lib_format = "%s%s"
    res_extension = ".res"      # compiled resource file
    exe_extension = ".exe"

def __init__ (self,
                  verbose=0,
                  dry_run=0,
                  force=0):

UnixCCompiler.__init__ (self, verbose, dry_run, force)

(status, details) = check_config_h()
        self.debug_print("Python's GCC status: %s (details: %s)" %
                         (status, details))
        if status is not CONFIG_H_OK:
            self.warn(
                "Python's pyconfig.h doesn't seem to support your compiler.  " +
                ("Reason: %s." % details) +
                "Compiling may fail because of undefined preprocessor macros.")

(self.gcc_version, self.ld_version) = \
            get_versions()
        self.debug_print(self.compiler_type + ": gcc %s, ld %s\n" %
                         (self.gcc_version,
                          self.ld_version) )

# Hard-code GCC because that's what this is all about.
        # XXX optimization, warnings etc. should be customizable.
        self.set_executables(compiler='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall',
                             compiler_so='gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Wall',
                             linker_exe='gcc -Zomf -Zmt -Zcrtdll',
                             linker_so='gcc -Zomf -Zmt -Zcrtdll -Zdll')

# want the gcc library statically linked (so that we don't have
        # to distribute a version dependent on the compiler we have)
        self.dll_libraries=["gcc"]

# __init__ ()

def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        if ext == '.rc':
            # gcc requires '.rc' compiled to binary ('.res') files !!!
            try:
                self.spawn(["rc", "-r", src])
            except DistutilsExecError, msg:
                raise CompileError, msg
        else: # for other files use the C-compiler
            try:
                self.spawn(self.compiler_so + cc_args + [src, '-o', obj] +
                           extra_postargs)
            except DistutilsExecError, msg:
                raise CompileError, msg

# use separate copies, so we can modify the lists
        extra_preargs = copy.copy(extra_preargs or [])
        libraries = copy.copy(libraries or [])
        objects = copy.copy(objects or [])

# Additional libraries
        libraries.extend(self.dll_libraries)

# handle export symbols by creating a def-file
        # with executables this only works with gcc/ld as linker
        if ((export_symbols is not None) and
            (target_desc != self.EXECUTABLE)):
            # (The linker doesn't do anything if output is up-to-date.
            # So it would probably better to check if we really need this,
            # but for this we had to insert some unchanged parts of
            # UnixCCompiler, and this is not what we want.)

# generate the filenames for these files
            def_file = os.path.join(temp_dir, dll_name + ".def")

# Generate .def file
            contents = [
                "LIBRARY %s INITINSTANCE TERMINSTANCE" % \
                os.path.splitext(os.path.basename(output_filename))[0],
                "DATA MULTIPLE NONSHARED",
                "EXPORTS"]
            for sym in export_symbols:
                contents.append('  "%s"' % sym)
            self.execute(write_file, (def_file, contents),
                         "writing %s" % def_file)

# next add options for def-file and to creating import libraries
            # for gcc/ld the def-file is specified as any other object files
            objects.append(def_file)

#end: if ((export_symbols is not None) and
        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):

# link ()

# -- Miscellaneous methods -----------------------------------------

# override the object_filenames method from CCompiler to
    # support rc and res-files
    def object_filenames (self,
                          source_filenames,
                          strip_dir=0,
                          output_dir=''):
        if output_dir is None: output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
            (base, ext) = os.path.splitext (os.path.normcase(src_name))
            if ext not in (self.src_extensions + ['.rc']):
                raise UnknownFileError, \
                      "unknown file type '%s' (from '%s')" % \
                      (ext, src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext == '.rc':
                # these need to be compiled to object files
                obj_names.append (os.path.join (output_dir,
                                            base + self.res_extension))
            else:
                obj_names.append (os.path.join (output_dir,
                                            base + self.obj_extension))
        return obj_names

# object_filenames ()

# override the find_library_file method from UnixCCompiler
    # to deal with file naming/searching differences
    def find_library_file(self, dirs, lib, debug=0):
        shortlib = '%s.lib' % lib
        longlib = 'lib%s.lib' % lib    # this form very rare

# get EMX's default library directory search path
        try:
            emx_dirs = os.environ['LIBRARY_PATH'].split(';')
        except KeyError:
            emx_dirs = []

for dir in dirs + emx_dirs:
            shortlibp = os.path.join(dir, shortlib)
            longlibp = os.path.join(dir, longlib)
            if os.path.exists(shortlibp):
                return shortlibp
            elif os.path.exists(longlibp):
                return longlibp

# Oops, didn't find it in *any* of 'dirs'
        return None

# class EMXCCompiler

# Because these compilers aren't configured in Python's pyconfig.h file by
# default, we should at least warn the user if he is using a unmodified
# version.

CONFIG_H_OK = "ok"
CONFIG_H_NOTOK = "not ok"
CONFIG_H_UNCERTAIN = "uncertain"

def check_config_h():

# XXX since this function also checks sys.version, it's not strictly a
    # "pyconfig.h" check -- should probably be renamed...

def get_versions():
    """ Try to find out the versions of gcc and ld.
        If not possible it returns None for it.
    """
    from distutils.version import StrictVersion
    from distutils.spawn import find_executable
    import re

gcc_exe = find_executable('gcc')
    if gcc_exe:
        out = os.popen(gcc_exe + ' -dumpversion','r')
        try:
            out_string = out.read()
        finally:
            out.close()
        result = re.search('(\d+\.\d+\.\d+)',out_string)
        if result:
            gcc_version = StrictVersion(result.group(1))
        else:
            gcc_version = None
    else:
        gcc_version = None
    # EMX ld has no way of reporting version number, and we use GCC
    # anyway - so we can link OMF DLLs
    ld_version = None
    return (gcc_version, ld_version)
emxccompiler.pyc000064400000016453151702014350007757 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZmZddlm	Z	ddl
mZddlm
Z
mZmZddlmZd	e	fd
��YZdZdZd
Zd�Zd�ZdS(s�distutils.emxccompiler

Provides the EMXCCompiler class, a subclass of UnixCCompiler that
handles the EMX port of the GNU C compiler to OS/2.
s$Id$i����N(tgen_preprocess_optionstgen_lib_options(t
UnixCCompiler(t
write_file(tDistutilsExecErrortCompileErrortUnknownFileError(tlogtEMXCCompilercBs�eZdZdZdZdZdZdZdZdZ	dddd�Z
d	�Zddddddddddd
�
Z
ddd�Zdd
�ZRS(temxs.objs.libs.dlls%s%ss.ress.exeic	Cs�tj||||�t�\}}|jd||f�|tk	rd|jdd|d�nt�\|_|_|j|j	d|j|jf�|j
ddddd	d
dd�d
g|_dS(Ns%Python's GCC status: %s (details: %s)s<Python's pyconfig.h doesn't seem to support your compiler.  sReason: %s.s<Compiling may fail because of undefined preprocessor macros.s: gcc %s, ld %s
tcompilers5gcc -Zomf -Zmt -O3 -fomit-frame-pointer -mprobe -Walltcompiler_sot
linker_exesgcc -Zomf -Zmt -Zcrtdllt	linker_sosgcc -Zomf -Zmt -Zcrtdll -Zdlltgcc(Rt__init__tcheck_config_htdebug_printtCONFIG_H_OKtwarntget_versionstgcc_versiont
ld_versiont
compiler_typetset_executablest
dll_libraries(tselftverbosetdry_runtforcetstatustdetails((s./usr/lib64/python2.7/distutils/emxccompiler.pyR*s"	cCs�|dkrHy|jdd|g�Wq�tk
rD}t|�q�XnHy)|j|j||d|g|�Wntk
r�}t|�nXdS(Ns.rctrcs-rs-o(tspawnRRR(Rtobjtsrctexttcc_argstextra_postargstpp_optstmsg((s./usr/lib64/python2.7/distutils/emxccompiler.pyt_compileMscCs�tj|
pg�}
tj|p$g�}tj|p9g�}|j|j�|dk	r;||jkr;tjj|d�}tjjtjj	|��\}}tjj
||d�}dtjjtjj	|��dddg}x|D]}|jd|�q�W|jt
||fd|�|j|�n|	sQ|
jd�ntj||||||||d|	|
|||
�dS(	Nis.defs$LIBRARY %s INITINSTANCE TERMINSTANCEsDATA MULTIPLE NONSHAREDtEXPORTSs  "%s"s
writing %ss-s(tcopytextendRtNonet
EXECUTABLEtostpathtdirnametsplitexttbasenametjointappendtexecuteRRtlink(Rttarget_desctobjectstoutput_filenamet
output_dirt	librariestlibrary_dirstruntime_library_dirstexport_symbolstdebugt
extra_preargsR&t
build_tempttarget_langttemp_dirtdll_namet
dll_extensiontdef_filetcontentstsym((s./usr/lib64/python2.7/distutils/emxccompiler.pyR7[sF		 	
	tcCs�|dkrd}ng}x�|D]�}tjjtjj|��\}}||jdgkrxtd||f�n|r�tjj|�}n|dkr�|jtjj	|||j
��q"|jtjj	|||j��q"W|S(NRJs.rcs"unknown file type '%s' (from '%s')(R-R/R0R2tnormcasetsrc_extensionsRR3R5R4t
res_extensiont
obj_extension(Rtsource_filenamest	strip_dirR;t	obj_namestsrc_nametbaseR$((s./usr/lib64/python2.7/distutils/emxccompiler.pytobject_filenames�s"	
$c
Cs�d|}d|}ytjdjd�}Wntk
rGg}nXxh||D]\}tjj||�}tjj||�}	tjj|�r�|Stjj|	�rS|	SqSWdS(Ns%s.libs	lib%s.libtLIBRARY_PATHt;(R/tenvirontsplittKeyErrorR0R4texistsR-(
RtdirstlibR@tshortlibtlonglibtemx_dirstdirt	shortlibptlonglibp((s./usr/lib64/python2.7/distutils/emxccompiler.pytfind_library_file�s

N(t__name__t
__module__RRNtstatic_lib_extensiontshared_lib_extensiontstatic_lib_formattshared_lib_formatRMt
exe_extensionRR)R-R7RTRc(((s./usr/lib64/python2.7/distutils/emxccompiler.pyRs2 	Ptoksnot okt	uncertaincCs�ddlm}ddl}|jtjd�dkrAtdfS|j�}y.t|�}z|j	�}Wd|j
�XWn'tk
r�}td||j
ffSX|j|d�dkr�td	|fStd
|fSdS(s�Check if the current Python installation (specifically, pyconfig.h)
    appears amenable to building extensions with GCC.  Returns a tuple
    (status, details), where 'status' is one of the following constants:
      CONFIG_H_OK
        all is well, go ahead and compile
      CONFIG_H_NOTOK
        doesn't look good
      CONFIG_H_UNCERTAIN
        not sure -- unable to read pyconfig.h
    'details' is a human-readable string explaining the situation.

Note there are two ways to conclude "OK": either 'sys.version' contains
    the string "GCC" (implying that this Python was built with GCC), or the
    installed "pyconfig.h" contains the string "__GNUC__".
    i����(t	sysconfigNtGCCissys.version mentions 'GCC'scouldn't read '%s': %st__GNUC__s'%s' mentions '__GNUC__'s '%s' does not mention '__GNUC__'(t	distutilsRmtstringtfindtsystversionRtget_config_h_filenametopentreadtclosetIOErrortCONFIG_H_UNCERTAINtstrerrortCONFIG_H_NOTOK(RmRqtfntftstexc((s./usr/lib64/python2.7/distutils/emxccompiler.pyR�s 
c	Cs�ddlm}ddlm}ddl}|d�}|r�tj|dd�}z|j�}Wd|j�X|j	d|�}|r�||j
d	��}q�d}nd}d}||fS(
sa Try to find out the versions of gcc and ld.
        If not possible it returns None for it.
    i����(t
StrictVersion(tfind_executableNRs
 -dumpversiontrs(\d+\.\d+\.\d+)i(tdistutils.versionR�tdistutils.spawnR�treR/tpopenRwRxtsearchtgroupR-(	R�R�R�tgcc_exetoutt
out_stringtresultRR((s./usr/lib64/python2.7/distutils/emxccompiler.pyR&s 	(t__doc__t__revision__R/RsR+tdistutils.ccompilerRRtdistutils.unixccompilerRtdistutils.file_utilRtdistutils.errorsRRRRpRRRR|RzRR(((s./usr/lib64/python2.7/distutils/emxccompiler.pyt<module>s$�	4emxccompiler.pyo000064400000016453151702014350007773 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZmZddlm	Z	ddl
mZddlm
Z
mZmZddlmZd	e	fd
��YZdZdZd
Zd�Zd�ZdS(s�distutils.emxccompiler

Note there are two ways to conclude "OK": either 'sys.version' contains
    the string "GCC" (implying that this Python was built with GCC), or the
    installed "pyconfig.h" contains the string "__GNUC__".
    i����(t	sysconfigNtGCCissys.version mentions 'GCC'scouldn't read '%s': %st__GNUC__s'%s' mentions '__GNUC__'s '%s' does not mention '__GNUC__'(t	distutilsRmtstringtfindtsystversionRtget_config_h_filenametopentreadtclosetIOErrortCONFIG_H_UNCERTAINtstrerrortCONFIG_H_NOTOK(RmRqtfntftstexc((s./usr/lib64/python2.7/distutils/emxccompiler.pyR�s 
c	Cs�ddlm}ddlm}ddl}|d�}|r�tj|dd�}z|j�}Wd|j�X|j	d|�}|r�||j
d	��}q�d}nd}d}||fS(
sa Try to find out the versions of gcc and ld.
        If not possible it returns None for it.
    i����(t
StrictVersion(tfind_executableNRs
 -dumpversiontrs(\d+\.\d+\.\d+)i(tdistutils.versionR�tdistutils.spawnR�treR/tpopenRwRxtsearchtgroupR-(	R�R�R�tgcc_exetoutt
out_stringtresultRR((s./usr/lib64/python2.7/distutils/emxccompiler.pyR&s 	(t__doc__t__revision__R/RsR+tdistutils.ccompilerRRtdistutils.unixccompilerRtdistutils.file_utilRtdistutils.errorsRRRRpRRRR|RzRR(((s./usr/lib64/python2.7/distutils/emxccompiler.pyt<module>s$�	4errors.py000064400000006646151702014350006444 0ustar00"""distutils.errors

This module is safe to use in "from ... import *" mode; it only exports
symbols whose names start with "Distutils" and end with "Error"."""

__revision__ = "$Id$"

class DistutilsError(Exception):
    """The root of all Distutils evil."""

class DistutilsModuleError(DistutilsError):
    """Unable to load an expected module, or to find an expected class
    within some module (in particular, command modules and classes)."""

class DistutilsClassError(DistutilsError):
    """Some command class (or possibly distribution class, if anyone
    feels a need to subclass Distribution) is found not to be holding
    up its end of the bargain, ie. implementing some part of the
    "command "interface."""

class DistutilsGetoptError(DistutilsError):
    """The option table provided to 'fancy_getopt()' is bogus."""

class DistutilsArgError(DistutilsError):
    """Raised by fancy_getopt in response to getopt.error -- ie. an
    error in the command line usage."""

class DistutilsFileError(DistutilsError):
    """Any problems in the filesystem: expected file not found, etc.
    Typically this is for problems that we detect before IOError or
    OSError could be raised."""

class DistutilsOptionError(DistutilsError):
    """Syntactic/semantic errors in command options, such as use of
    mutually conflicting options, or inconsistent options,
    badly-spelled values, etc.  No distinction is made between option
    values originating in the setup script, the command line, config
    files, or what-have-you -- but if we *know* something originated in
    the setup script, we'll raise DistutilsSetupError instead."""

class DistutilsSetupError(DistutilsError):
    """For errors that can be definitely blamed on the setup script,
    such as invalid keyword arguments to 'setup()'."""

class DistutilsPlatformError(DistutilsError):
    """We don't know how to do something on the current platform (but
    we do know how to do it on some platform) -- eg. trying to compile
    C files on a platform not supported by a CCompiler subclass."""

class DistutilsExecError(DistutilsError):
    """Any problems executing an external program (such as the C
    compiler, when compiling C files)."""

class DistutilsInternalError(DistutilsError):
    """Internal inconsistencies or impossibilities (obviously, this
    should never be seen if the code is working!)."""

class DistutilsTemplateError(DistutilsError):
    """Syntax error in a file list template."""

class DistutilsByteCompileError(DistutilsError):
    """Byte compile error."""

# Exception classes used by the CCompiler implementation classes
class CCompilerError(Exception):
    """Some compile/link operation failed."""

class PreprocessError(CCompilerError):
    """Failure to preprocess one or more C/C++ files."""

class CompileError(CCompilerError):
    """Failure to compile one or more C/C++ source files."""

class LibError(CCompilerError):
    """Failure to create a static library from one or more C/C++ object
    files."""

class LinkError(CCompilerError):
    """Failure to link one or more C/C++ object files into an executable
    or shared library file."""

class UnknownFileError(CCompilerError):
    """Attempt to process an unknown file type."""
errors.pyo000064400000014215151702014350006612 0ustar00�
{fc@s�dZdZdefd��YZdefd��YZdefd��YZdefd	��YZd
efd��YZdefd
��YZdefd��YZ	defd��YZ
defd��YZdefd��YZdefd��YZ
defd��YZdefd��YZdefd��YZdefd��YZd efd!��YZd"efd#��YZd$efd%��YZd&efd'��YZd(S()s�distutils.errors

This module is safe to use in "from ... import *" mode; it only exports
symbols whose names start with "Distutils" and end with "Error".s$Id$tDistutilsErrorcBseZdZRS(sThe root of all Distutils evil.(t__name__t
__module__t__doc__(((s(/usr/lib64/python2.7/distutils/errors.pyR
stDistutilsModuleErrorcBseZdZRS(s�Unable to load an expected module, or to find an expected class
    within some module (in particular, command modules and classes).(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRstDistutilsClassErrorcBseZdZRS(s�Some command class (or possibly distribution class, if anyone
    feels a need to subclass Distribution) is found not to be holding
    up its end of the bargain, ie. implementing some part of the
    "command "interface.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRstDistutilsGetoptErrorcBseZdZRS(s7The option table provided to 'fancy_getopt()' is bogus.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRstDistutilsArgErrorcBseZdZRS(saRaised by fancy_getopt in response to getopt.error -- ie. an
    error in the command line usage.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRstDistutilsFileErrorcBseZdZRS(s�Any problems in the filesystem: expected file not found, etc.
    Typically this is for problems that we detect before IOError or
    OSError could be raised.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR!stDistutilsOptionErrorcBseZdZRS(s�Syntactic/semantic errors in command options, such as use of
    mutually conflicting options, or inconsistent options,
    badly-spelled values, etc.  No distinction is made between option
    values originating in the setup script, the command line, config
    files, or what-have-you -- but if we *know* something originated in
    the setup script, we'll raise DistutilsSetupError instead.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR	&stDistutilsSetupErrorcBseZdZRS(sqFor errors that can be definitely blamed on the setup script,
    such as invalid keyword arguments to 'setup()'.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR
.stDistutilsPlatformErrorcBseZdZRS(s�We don't know how to do something on the current platform (but
    we do know how to do it on some platform) -- eg. trying to compile
    C files on a platform not supported by a CCompiler subclass.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR2stDistutilsExecErrorcBseZdZRS(s`Any problems executing an external program (such as the C
    compiler, when compiling C files).(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR7stDistutilsInternalErrorcBseZdZRS(soInternal inconsistencies or impossibilities (obviously, this
    should never be seen if the code is working!).(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR
;stDistutilsTemplateErrorcBseZdZRS(s%Syntax error in a file list template.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyR?stDistutilsByteCompileErrorcBseZdZRS(sByte compile error.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRBstCCompilerErrorcBseZdZRS(s#Some compile/link operation failed.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRFstPreprocessErrorcBseZdZRS(s.Failure to preprocess one or more C/C++ files.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRIstCompileErrorcBseZdZRS(s2Failure to compile one or more C/C++ source files.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRLstLibErrorcBseZdZRS(sKFailure to create a static library from one or more C/C++ object
    files.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyROst	LinkErrorcBseZdZRS(s]Failure to link one or more C/C++ object files into an executable
    or shared library file.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRSstUnknownFileErrorcBseZdZRS(s(Attempt to process an unknown file type.(RRR(((s(/usr/lib64/python2.7/distutils/errors.pyRWsN(Rt__revision__t	ExceptionRRRRRRR	R
RRR
RRRRRRRR(((s(/usr/lib64/python2.7/distutils/errors.pyt<module>	s(extension.py000064400000025230151702014350007132 0ustar00"""distutils.extension

Provides the Extension class, used to describe C/C++ extension
modules in setup scripts."""

__revision__ = "$Id$"

import os, string, sys
from types import *

try:
    import warnings
except ImportError:
    warnings = None

# This class is really only used by the "build_ext" command, so it might
# make sense to put it in distutils.command.build_ext.  However, that
# module is already big enough, and I want to make this class a bit more
# complex to simplify some common cases ("foo" module in "foo.c") and do
# better error-checking ("foo.c" actually exists).
#
# Also, putting this in build_ext.py means every setup script would have to
# import that large-ish module (indirectly, through distutils.core) in
# order to do anything.

class Extension:
    """Just a collection of attributes that describes an extension
    module and everything needed to build it (hopefully in a portable
    way, but there are hooks that let you be as unportable as you need).

# When adding arguments to this constructor, be sure to update
    # setup_keywords in core.py.
    def __init__ (self, name, sources,
                  include_dirs=None,
                  define_macros=None,
                  undef_macros=None,
                  library_dirs=None,
                  libraries=None,
                  runtime_library_dirs=None,
                  extra_objects=None,
                  extra_compile_args=None,
                  extra_link_args=None,
                  export_symbols=None,
                  swig_opts = None,
                  depends=None,
                  language=None,
                  **kw                      # To catch unknown keywords
                 ):
        assert type(name) is StringType, "'name' must be a string"
        assert (type(sources) is ListType and
                map(type, sources) == [StringType]*len(sources)), \
                "'sources' must be a list of strings"

self.name = name
        self.sources = sources
        self.include_dirs = include_dirs or []
        self.define_macros = define_macros or []
        self.undef_macros = undef_macros or []
        self.library_dirs = library_dirs or []
        self.libraries = libraries or []
        self.runtime_library_dirs = runtime_library_dirs or []
        self.extra_objects = extra_objects or []
        self.extra_compile_args = extra_compile_args or []
        self.extra_link_args = extra_link_args or []
        self.export_symbols = export_symbols or []
        self.swig_opts = swig_opts or []
        self.depends = depends or []
        self.language = language

# If there are unknown keyword options, warn about them
        if len(kw):
            L = kw.keys() ; L.sort()
            L = map(repr, L)
            msg = "Unknown Extension options: " + string.join(L, ', ')
            if warnings is not None:
                warnings.warn(msg)
            else:
                sys.stderr.write(msg + '\n')
# class Extension

def read_setup_file (filename):
    from distutils.sysconfig import \
         parse_makefile, expand_makefile_vars, _variable_rx
    from distutils.text_file import TextFile
    from distutils.util import split_quoted

# First pass over the file to gather "VAR = VALUE" assignments.
    vars = parse_makefile(filename)

# Second pass to gobble up the real content: lines of the form
    #   <module> ... [<sourcefile> ...] [<cpparg> ...] [<library> ...]
    file = TextFile(filename,
                    strip_comments=1, skip_blanks=1, join_lines=1,
                    lstrip_ws=1, rstrip_ws=1)
    try:
        extensions = []

while 1:
            line = file.readline()
            if line is None:                # eof
                break
            if _variable_rx.match(line):    # VAR=VALUE, handled in first pass
                continue

if line[0] == line[-1] == "*":
                    file.warn("'%s' lines not handled yet" % line)
                    continue

#print "original line: " + line
            line = expand_makefile_vars(line, vars)
            words = split_quoted(line)
            #print "expanded line: " + line

# NB. this parses a slightly different syntax than the old
            # makesetup script: here, there must be exactly one extension per
            # line, and it must be the first word of the line.  I have no idea
            # why the old syntax supported multiple extensions per line, as
            # they all wind up being the same.

module = words[0]
            ext = Extension(module, [])
            append_next_word = None

for word in words[1:]:
                if append_next_word is not None:
                    append_next_word.append(word)
                    append_next_word = None
                    continue

suffix = os.path.splitext(word)[1]
                switch = word[0:2] ; value = word[2:]

if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
                    # hmm, should we do something about C vs. C++ sources?
                    # or leave it up to the CCompiler implementation to
                    # worry about?
                    ext.sources.append(word)
                elif switch == "-I":
                    ext.include_dirs.append(value)
                elif switch == "-D":
                    equals = string.find(value, "=")
                    if equals == -1:        # bare "-DFOO" -- no value
                        ext.define_macros.append((value, None))
                    else:                   # "-DFOO=blah"
                        ext.define_macros.append((value[0:equals],
                                                  value[equals+2:]))
                elif switch == "-U":
                    ext.undef_macros.append(value)
                elif switch == "-C":        # only here 'cause makesetup has it!
                    ext.extra_compile_args.append(word)
                elif switch == "-l":
                    ext.libraries.append(value)
                elif switch == "-L":
                    ext.library_dirs.append(value)
                elif switch == "-R":
                    ext.runtime_library_dirs.append(value)
                elif word == "-rpath":
                    append_next_word = ext.runtime_library_dirs
                elif word == "-Xlinker":
                    append_next_word = ext.extra_link_args
                elif word == "-Xcompiler":
                    append_next_word = ext.extra_compile_args
                elif switch == "-u":
                    ext.extra_link_args.append(word)
                    if not value:
                        append_next_word = ext.extra_link_args
                elif word == "-Xcompiler":
                    append_next_word = ext.extra_compile_args
                elif switch == "-u":
                    ext.extra_link_args.append(word)
                    if not value:
                        append_next_word = ext.extra_link_args
                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
                    # NB. a really faithful emulation of makesetup would
                    # append a .o file to extra_objects only if it
                    # had a slash in it; otherwise, it would s/.o/.c/
                    # and append it to sources.  Hmmmm.
                    ext.extra_objects.append(word)
                else:
                    file.warn("unrecognized argument '%s'" % word)

extensions.append(ext)
    finally:
        file.close()

#print "module:", module
        #print "source files:", source_files
        #print "cpp args:", cpp_args
        #print "lib args:", library_args

#extensions[module] = { 'sources': source_files,
        #                       'cpp_args': cpp_args,
        #                       'lib_args': library_args }

return extensions

# read_setup_file ()
filelist.py000064400000030621151702014350006731 0ustar00"""distutils.filelist

Provides the FileList class, used for poking about the filesystem
and building lists of files.
"""

__revision__ = "$Id$"

import os, re
import fnmatch
from distutils.util import convert_path
from distutils.errors import DistutilsTemplateError, DistutilsInternalError
from distutils import log

class FileList:
    """A list of files built by on exploring the filesystem and filtered by
    applying various patterns to what we find there.

def __init__(self, warn=None, debug_print=None):
        # ignore argument to FileList, but keep them for backwards
        # compatibility
        self.allfiles = None
        self.files = []

def set_allfiles(self, allfiles):
        self.allfiles = allfiles

def findall(self, dir=os.curdir):
        self.allfiles = findall(dir)

def debug_print(self, msg):
        """Print 'msg' to stdout if the global DEBUG (taken from the
        DISTUTILS_DEBUG environment variable) flag is true.
        """
        from distutils.debug import DEBUG
        if DEBUG:
            print msg

# -- List-like methods ---------------------------------------------

def append(self, item):
        self.files.append(item)

def extend(self, items):
        self.files.extend(items)

def sort(self):
        # Not a strict lexical sort!
        sortable_files = map(os.path.split, self.files)
        sortable_files.sort()
        self.files = []
        for sort_tuple in sortable_files:
            self.files.append(os.path.join(*sort_tuple))

# -- Other miscellaneous utility methods ---------------------------

def remove_duplicates(self):
        # Assumes list has been sorted!
        for i in range(len(self.files) - 1, 0, -1):
            if self.files[i] == self.files[i - 1]:
                del self.files[i]

# -- "File template" methods ---------------------------------------

def _parse_template_line(self, line):
        words = line.split()
        action = words[0]

patterns = dir = dir_pattern = None

if action in ('include', 'exclude',
                      'global-include', 'global-exclude'):
            if len(words) < 2:
                raise DistutilsTemplateError, \
                      "'%s' expects <pattern1> <pattern2> ..." % action

patterns = map(convert_path, words[1:])

elif action in ('recursive-include', 'recursive-exclude'):
            if len(words) < 3:
                raise DistutilsTemplateError, \
                      "'%s' expects <dir> <pattern1> <pattern2> ..." % action

dir = convert_path(words[1])
            patterns = map(convert_path, words[2:])

elif action in ('graft', 'prune'):
            if len(words) != 2:
                raise DistutilsTemplateError, \
                     "'%s' expects a single <dir_pattern>" % action

dir_pattern = convert_path(words[1])

else:
            raise DistutilsTemplateError, "unknown action '%s'" % action

return (action, patterns, dir, dir_pattern)

def process_template_line(self, line):
        # Parse the line: split it up, make sure the right number of words
        # is there, and return the relevant words.  'action' is always
        # defined: it's the first word of the line.  Which of the other
        # three are defined depends on the action; it'll be either
        # patterns, (dir and patterns), or (dir_pattern).
        action, patterns, dir, dir_pattern = self._parse_template_line(line)

# OK, now we know that the action is valid and we have the
        # right number of words on the line for that action -- so we
        # can proceed with minimal error-checking.
        if action == 'include':
            self.debug_print("include " + ' '.join(patterns))
            for pattern in patterns:
                if not self.include_pattern(pattern, anchor=1):
                    log.warn("warning: no files found matching '%s'",
                             pattern)

elif action == 'exclude':
            self.debug_print("exclude " + ' '.join(patterns))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, anchor=1):
                    log.warn(("warning: no previously-included files "
                              "found matching '%s'"), pattern)

elif action == 'global-include':
            self.debug_print("global-include " + ' '.join(patterns))
            for pattern in patterns:
                if not self.include_pattern(pattern, anchor=0):
                    log.warn(("warning: no files found matching '%s' " +
                              "anywhere in distribution"), pattern)

elif action == 'global-exclude':
            self.debug_print("global-exclude " + ' '.join(patterns))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, anchor=0):
                    log.warn(("warning: no previously-included files matching "
                              "'%s' found anywhere in distribution"),
                             pattern)

elif action == 'recursive-include':
            self.debug_print("recursive-include %s %s" %
                             (dir, ' '.join(patterns)))
            for pattern in patterns:
                if not self.include_pattern(pattern, prefix=dir):
                    log.warn(("warning: no files found matching '%s' " +
                                "under directory '%s'"),
                             pattern, dir)

elif action == 'recursive-exclude':
            self.debug_print("recursive-exclude %s %s" %
                             (dir, ' '.join(patterns)))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, prefix=dir):
                    log.warn(("warning: no previously-included files matching "
                              "'%s' found under directory '%s'"),
                             pattern, dir)

elif action == 'graft':
            self.debug_print("graft " + dir_pattern)
            if not self.include_pattern(None, prefix=dir_pattern):
                log.warn("warning: no directories found matching '%s'",
                         dir_pattern)

elif action == 'prune':
            self.debug_print("prune " + dir_pattern)
            if not self.exclude_pattern(None, prefix=dir_pattern):
                log.warn(("no previously-included directories found " +
                          "matching '%s'"), dir_pattern)
        else:
            raise DistutilsInternalError, \
                  "this cannot happen: invalid action '%s'" % action

# -- Filtering/selection methods -----------------------------------

def include_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
        """Select strings (presumably filenames) from 'self.files' that
        match 'pattern', a Unix-style wildcard (glob) pattern.

Patterns are not quite the same as implemented by the 'fnmatch'
        module: '*' and '?'  match non-special characters, where "special"
        is platform-dependent: slash on Unix; colon, slash, and backslash on
        DOS/Windows; and colon on Mac OS.

If 'anchor' is true (the default), then the pattern match is more
        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
        'anchor' is false, both of these will match.

If 'prefix' is supplied, then only filenames starting with 'prefix'
        (itself a pattern) and ending with 'pattern', with anything in between
        them, will match.  'anchor' is ignored in this case.

If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
        'pattern' is assumed to be either a string containing a regex or a
        regex object -- no translation is done, the regex is just compiled
        and used as-is.

Selected strings will be added to self.files.

Return 1 if files are found.
        """
        # XXX docstring lying about what the special chars are?
        files_found = 0
        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
        self.debug_print("include_pattern: applying regex r'%s'" %
                         pattern_re.pattern)

# delayed loading of allfiles list
        if self.allfiles is None:
            self.findall()

for name in self.allfiles:
            if pattern_re.search(name):
                self.debug_print(" adding " + name)
                self.files.append(name)
                files_found = 1

return files_found

def exclude_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
        """Remove strings (presumably filenames) from 'files' that match
        'pattern'.

Other parameters are the same as for 'include_pattern()', above.
        The list 'self.files' is modified in place. Return 1 if files are
        found.
        """
        files_found = 0
        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
        self.debug_print("exclude_pattern: applying regex r'%s'" %
                         pattern_re.pattern)
        for i in range(len(self.files)-1, -1, -1):
            if pattern_re.search(self.files[i]):
                self.debug_print(" removing " + self.files[i])
                del self.files[i]
                files_found = 1

return files_found

# ----------------------------------------------------------------------
# Utility functions

def findall(dir = os.curdir):
    """Find all files under 'dir' and return the list of full filenames
    (relative to 'dir').
    """
    from stat import ST_MODE, S_ISREG, S_ISDIR, S_ISLNK

list = []
    stack = [dir]
    pop = stack.pop
    push = stack.append

while stack:
        dir = pop()
        names = os.listdir(dir)

for name in names:
            if dir != os.curdir:        # avoid the dreaded "./" syndrome
                fullname = os.path.join(dir, name)
            else:
                fullname = name

# Avoid excess stat calls -- just one will do, thank you!
            stat = os.stat(fullname)
            mode = stat[ST_MODE]
            if S_ISREG(mode):
                list.append(fullname)
            elif S_ISDIR(mode) and not S_ISLNK(mode):
                push(fullname)

return list

def glob_to_re(pattern):
    """Translate a shell-like glob pattern to a regular expression.

Return a string containing the regex.  Differs from
    'fnmatch.translate()' in that '*' does not match "special characters"
    (which are platform-specific).
    """
    pattern_re = fnmatch.translate(pattern)

# '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
    # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
    # and by extension they shouldn't match such "special characters" under
    # any OS.  So change all non-escaped dots in the RE to match any
    # character except the special characters (currently: just os.sep).
    sep = os.sep
    if os.sep == '\\':
        # we're using a regex to manipulate a regex, so we need
        # to escape the backslash twice
        sep = r'\\\\'
    escaped = r'\1[^%s]' % sep
    pattern_re = re.sub(r'((?<!\\)(\\\\)*)\.', escaped, pattern_re)
    return pattern_re

def translate_pattern(pattern, anchor=1, prefix=None, is_regex=0):
    """Translate a shell-like wildcard pattern to a compiled regular
    expression.

Return the compiled regex.  If 'is_regex' true,
    then 'pattern' is directly compiled to a regex (if it's a string)
    or just returned as-is (assumes it's a regex object).
    """
    if is_regex:
        if isinstance(pattern, str):
            return re.compile(pattern)
        else:
            return pattern

if pattern:
        pattern_re = glob_to_re(pattern)
    else:
        pattern_re = ''

if prefix is not None:
        # ditch end of pattern character
        empty_pattern = glob_to_re('')
        prefix_re = glob_to_re(prefix)[:-len(empty_pattern)]
        sep = os.sep
        if os.sep == '\\':
            sep = r'\\'
        pattern_re = "^" + sep.join((prefix_re, ".*" + pattern_re))
    else:                               # no prefix -- respect anchor flag
        if anchor:
            pattern_re = "^" + pattern_re

return re.compile(pattern_re)
filelist.pyc000064400000025004151702014350007073 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZddlmZm	Z	ddl
mZddd��YZej
d	�Zd
�Zdddd
�ZdS(ssdistutils.filelist

Provides the FileList class, used for poking about the filesystem
and building lists of files.
s$Id$i����N(tconvert_path(tDistutilsTemplateErrortDistutilsInternalError(tlogtFileListcBs�eZdZddd�Zd�Zejd�Zd�Z	d�Z
d�Zd�Zd�Z
d	�Zd
�Zdddd
�Zdddd�ZRS(s�A list of files built by on exploring the filesystem and filtered by
    applying various patterns to what we find there.

Instance attributes:
      dir
        directory from which files will be taken -- only used if
        'allfiles' not supplied to constructor
      files
        list of filenames currently being built/filtered/manipulated
      allfiles
        complete list of files under consideration (ie. without any
        filtering applied)
    cCsd|_g|_dS(N(tNonetallfilestfiles(tselftwarntdebug_print((s*/usr/lib64/python2.7/distutils/filelist.pyt__init__s	cCs
||_dS(N(R(RR((s*/usr/lib64/python2.7/distutils/filelist.pytset_allfiles$scCst|�|_dS(N(tfindallR(Rtdir((s*/usr/lib64/python2.7/distutils/filelist.pyR
'scCs"ddlm}|r|GHndS(s~Print 'msg' to stdout if the global DEBUG (taken from the
        DISTUTILS_DEBUG environment variable) flag is true.
        i����(tDEBUGN(tdistutils.debugR(RtmsgR((s*/usr/lib64/python2.7/distutils/filelist.pyR
*scCs|jj|�dS(N(Rtappend(Rtitem((s*/usr/lib64/python2.7/distutils/filelist.pyR4scCs|jj|�dS(N(Rtextend(Rtitems((s*/usr/lib64/python2.7/distutils/filelist.pyR7scCs\ttjj|j�}|j�g|_x*|D]"}|jjtjj|��q2WdS(N(tmaptostpathtsplitRtsortRtjoin(Rtsortable_filest
sort_tuple((s*/usr/lib64/python2.7/distutils/filelist.pyR:s

cCsYxRtt|j�ddd�D]1}|j||j|dkr |j|=q q WdS(Niii����(trangetlenR(Rti((s*/usr/lib64/python2.7/distutils/filelist.pytremove_duplicatesEs&cCs|j�}|d}d}}}|dkrht|�dkrRtd|�ntt|d�}n�|dkr�t|�dkr�td|�nt|d�}tt|d�}nN|dkr�t|�dkr�td|�nt|d�}n
td|�||||fS(Nitincludetexcludesglobal-includesglobal-excludeis&'%s' expects <pattern1> <pattern2> ...isrecursive-includesrecursive-excludeis,'%s' expects <dir> <pattern1> <pattern2> ...tgrafttprunes#'%s' expects a single <dir_pattern>sunknown action '%s'(R"R#sglobal-includesglobal-exclude(srecursive-includesrecursive-exclude(R$R%(RRRRRR(RtlinetwordstactiontpatternsRtdir_pattern((s*/usr/lib64/python2.7/distutils/filelist.pyt_parse_template_lineNs,

cCs&|j|�\}}}}|dkr}|jddj|��x�|D].}|j|dd�sHtjd|�qHqHWn�|dkr�|jddj|��x||D].}|j|dd�s�tjd	|�q�q�WnC|d
krE|jddj|��x|D]2}|j|dd�stjd
d|�qqWn�|dkr�|jddj|��x�|D].}|j|dd�srtjd|�qrqrWn{|dkr|jd|dj|�f�xL|D]5}|j|d|�s�tjd
d||�q�q�Wn|dkr�|jd|dj|�f�x�|D]1}|j|d|�sItjd||�qIqIWn�|dkr�|jd|�|jdd|�s"tjd|�q"nY|dkr|jd|�|jdd|�s"tjdd|�q"n
td |�dS(!NR"sinclude t tanchoris%warning: no files found matching '%s'R#sexclude s9warning: no previously-included files found matching '%s'sglobal-includesglobal-include is&warning: no files found matching '%s' sanywhere in distributionsglobal-excludesglobal-exclude sRwarning: no previously-included files matching '%s' found anywhere in distributionsrecursive-includesrecursive-include %s %stprefixsunder directory '%s'srecursive-excludesrecursive-exclude %s %ssNwarning: no previously-included files matching '%s' found under directory '%s'R$sgraft s+warning: no directories found matching '%s'R%sprune s)no previously-included directories found s
matching '%s's'this cannot happen: invalid action '%s'(	R+R
Rtinclude_patternRR	texclude_patternRR(RR&R(R)RR*tpattern((s*/usr/lib64/python2.7/distutils/filelist.pytprocess_template_linepsh
	
	
	
		
		
		
	iicCs�d}t||||�}|jd|j�|jdkrK|j�nxJ|jD]?}|j|�rU|jd|�|jj|�d}qUqUW|S(s�Select strings (presumably filenames) from 'self.files' that
        match 'pattern', a Unix-style wildcard (glob) pattern.

If 'anchor' is true (the default), then the pattern match is more
        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
        'anchor' is false, both of these will match.

Selected strings will be added to self.files.

Return 1 if files are found.
        is%include_pattern: applying regex r'%s's adding iN(	ttranslate_patternR
R1RRR
tsearchRR(RR1R-R.tis_regextfiles_foundt
pattern_retname((s*/usr/lib64/python2.7/distutils/filelist.pyR/�s

cCs�d}t||||�}|jd|j�xhtt|j�ddd�D]G}|j|j|�rO|jd|j|�|j|=d}qOqOW|S(s�Remove strings (presumably filenames) from 'files' that match
        'pattern'.

Other parameters are the same as for 'include_pattern()', above.
        The list 'self.files' is modified in place. Return 1 if files are
        found.
        is%exclude_pattern: applying regex r'%s'ii����s
 removing (R3R
R1RRRR4(RR1R-R.R5R6R7R ((s*/usr/lib64/python2.7/distutils/filelist.pyR0�s	&

N(t__name__t
__module__t__doc__RRRRtcurdirR
R
RRRR!R+R2R/R0(((s*/usr/lib64/python2.7/distutils/filelist.pyRs
		
						"	K-cCsddlm}m}m}m}g}|g}|j}|j}x�|r|�}tj|�}	x�|	D]�}
|tj	kr�tj
j||
�}n|
}tj|�}||}
||
�r�|j|�qk||
�rk||
�rk||�qkqkWqFW|S(s^Find all files under 'dir' and return the list of full filenames
    (relative to 'dir').
    i����(tST_MODEtS_ISREGtS_ISDIRtS_ISLNK(tstatR=R>R?R@tpopRRtlistdirR<RR(RR=R>R?R@tlisttstackRBtpushtnamesR8tfullnameRAtmode((s*/usr/lib64/python2.7/distutils/filelist.pyR
s&"

cCsStj|�}tj}tjdkr0d}nd|}tjd||�}|S(s�Translate a shell-like glob pattern to a regular expression.

Return a string containing the regex.  Differs from
    'fnmatch.translate()' in that '*' does not match "special characters"
    (which are platform-specific).
    s\s\\\\s\1[^%s]s((?<!\\)(\\\\)*)\.(tfnmatcht	translateRtseptretsub(R1R7RLtescaped((s*/usr/lib64/python2.7/distutils/filelist.pyt
glob_to_re s		
iicCs�|r)t|t�r"tj|�S|Sn|r>t|�}nd}|dk	r�td�}t|�t|� }tj}tjdkr�d}nd|j	|d|f�}n|r�d|}ntj|�S(sTranslate a shell-like wildcard pattern to a compiled regular
    expression.

Return the compiled regex.  If 'is_regex' true,
    then 'pattern' is directly compiled to a regex (if it's a string)
    or just returned as-is (assumes it's a regex object).
    ts\s\\t^s.*N(
t
isinstancetstrRMtcompileRPRRRRLR(R1R-R.R5R7t
empty_patternt	prefix_reRL((s*/usr/lib64/python2.7/distutils/filelist.pyR38s"
		 
((R;t__revision__RRMRJtdistutils.utilRtdistutils.errorsRRt	distutilsRRR<R
RPRR3(((s*/usr/lib64/python2.7/distutils/filelist.pyt<module>s� 	filelist.pyo000064400000025004151702014350007107 0ustar00�
{fc@s�dZdZddlZddlZddlZddlmZddlmZm	Z	ddl
mZddd��YZej
d	�Zd
�Zdddd
�ZdS(ssdistutils.filelist

If 'anchor' is true (the default), then the pattern match is more
        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
        'anchor' is false, both of these will match.

Selected strings will be added to self.files.

cCs�d}t||||�}|jd|j�xhtt|j�ddd�D]G}|j|j|�rO|jd|j|�|j|=d}qOqOW|S(s�Remove strings (presumably filenames) from 'files' that match
        'pattern'.

cCsStj|�}tj}tjdkr0d}nd|}tjd||�}|S(s�Translate a shell-like glob pattern to a regular expression.

Return the compiled regex.  If 'is_regex' true,
    then 'pattern' is directly compiled to a regex (if it's a string)
    or just returned as-is (assumes it's a regex object).
    ts\s\\t^s.*N(
t
isinstancetstrRMtcompileRPRRRRLR(R1R-R.R5R7t
empty_patternt	prefix_reRL((s*/usr/lib64/python2.7/distutils/filelist.pyR38s"
		 
((R;t__revision__RRMRJtdistutils.utilRtdistutils.errorsRRt	distutilsRRR<R
RPRR3(((s*/usr/lib64/python2.7/distutils/filelist.pyt<module>s� 	log.py000064400000003226151702014350005700 0ustar00"""A simple log mechanism styled after PEP 282."""

# The class here is styled after PEP 282 so that it could later be
# replaced with a standard Python logging implementation.

DEBUG = 1
INFO = 2
WARN = 3
ERROR = 4
FATAL = 5

import sys

class Log:

def __init__(self, threshold=WARN):
        self.threshold = threshold

def _log(self, level, msg, args):
        if level not in (DEBUG, INFO, WARN, ERROR, FATAL):
            raise ValueError('%s wrong log level' % str(level))

if level >= self.threshold:
            if args:
                msg = msg % args
            if level in (WARN, ERROR, FATAL):
                stream = sys.stderr
            else:
                stream = sys.stdout
            stream.write('%s\n' % msg)
            stream.flush()

def log(self, level, msg, *args):
        self._log(level, msg, args)

def debug(self, msg, *args):
        self._log(DEBUG, msg, args)

def info(self, msg, *args):
        self._log(INFO, msg, args)

def warn(self, msg, *args):
        self._log(WARN, msg, args)

def error(self, msg, *args):
        self._log(ERROR, msg, args)

def fatal(self, msg, *args):
        self._log(FATAL, msg, args)

_global_log = Log()
log = _global_log.log
debug = _global_log.debug
info = _global_log.info
warn = _global_log.warn
error = _global_log.error
fatal = _global_log.fatal

def set_threshold(level):
    # return the old threshold for use from tests
    old = _global_log.threshold
    _global_log.threshold = level
    return old

def set_verbosity(v):
    if v <= 0:
        set_threshold(WARN)
    elif v == 1:
        set_threshold(INFO)
    elif v >= 2:
        set_threshold(DEBUG)
log.pyo000064400000005342151702014350006060 0ustar00�
{fc@s�dZdZdZdZdZdZddlZddd	��YZe�Zej	Z	ej
Z
ejZejZej
Z
ejZd
�Zd�ZdS(
s,A simple log mechanism styled after PEP 282.iiiiii����NtLogcBsSeZed�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
RS(cCs
||_dS(N(t	threshold(tselfR((s%/usr/lib64/python2.7/distutils/log.pyt__init__scCs�|tttttfkr4tdt|���n||jkr�|rV||}n|tttfkrwtj	}n	tj
}|jd|�|j�ndS(Ns%s wrong log levels%s
(
tDEBUGtINFOtWARNtERRORtFATALt
ValueErrortstrRtsyststderrtstdouttwritetflush(Rtleveltmsgtargststream((s%/usr/lib64/python2.7/distutils/log.pyt_logs
	cGs|j|||�dS(N(R(RRRR((s%/usr/lib64/python2.7/distutils/log.pytlog!scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pytdebug$scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pytinfo'scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pytwarn*scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pyterror-scGs|jt||�dS(N(RR(RRR((s%/usr/lib64/python2.7/distutils/log.pytfatal0s(t__name__t
__module__RRRRRRRRR(((s%/usr/lib64/python2.7/distutils/log.pyRs						cCstj}|t_|S(N(t_global_logR(Rtold((s%/usr/lib64/python2.7/distutils/log.pyt
set_threshold;s		cCsO|dkrtt�n2|dkr2tt�n|dkrKtt�ndS(Niii(RRRR(tv((s%/usr/lib64/python2.7/distutils/log.pyt
set_verbosityAs

((t__doc__RRRRRRRRRRRRRRRR!(((s%/usr/lib64/python2.7/distutils/log.pyt<module>s %								msvc9compiler.py000064400000074434151702014350007724 0ustar00"""distutils.msvc9compiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio 2008.

The module is compatible with VS 2005 and VS 2008. You can find legacy support
for older versions of VS in distutils.msvccompiler.
"""

# Written by Perry Stoll
# hacked by Robin Becker and Thomas Heller to do a better job of
#   finding DevStudio (through the registry)
# ported to VS2005 and VS 2008 by Christian Heimes

__revision__ = "$Id$"

import os
import subprocess
import sys
import re

import _winreg

RegOpenKeyEx = _winreg.OpenKeyEx
RegEnumKey = _winreg.EnumKey
RegEnumValue = _winreg.EnumValue
RegError = _winreg.error

HKEYS = (_winreg.HKEY_USERS,
         _winreg.HKEY_CURRENT_USER,
         _winreg.HKEY_LOCAL_MACHINE,
         _winreg.HKEY_CLASSES_ROOT)

NATIVE_WIN64 = (sys.platform == 'win32' and sys.maxsize > 2**32)
if NATIVE_WIN64:
    # Visual C++ is a 32-bit application, so we need to look in
    # the corresponding registry branch, if we're running a
    # 64-bit Python on Win64
    VS_BASE = r"Software\Wow6432Node\Microsoft\VisualStudio\%0.1f"
    VSEXPRESS_BASE = r"Software\Wow6432Node\Microsoft\VCExpress\%0.1f"
    WINSDK_BASE = r"Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows"
    NET_BASE = r"Software\Wow6432Node\Microsoft\.NETFramework"
else:
    VS_BASE = r"Software\Microsoft\VisualStudio\%0.1f"
    VSEXPRESS_BASE = r"Software\Microsoft\VCExpress\%0.1f"
    WINSDK_BASE = r"Software\Microsoft\Microsoft SDKs\Windows"
    NET_BASE = r"Software\Microsoft\.NETFramework"

# A map keyed by get_platform() return values to values accepted by
# 'vcvarsall.bat'.  Note a cross-compile may combine these (eg, 'x86_amd64' is
# the param to cross-compile on x86 targeting amd64.)
PLAT_TO_VCVARS = {
    'win32' : 'x86',
    'win-amd64' : 'amd64',
    'win-ia64' : 'ia64',
}

class Reg:
    """Helper class to read values from the registry
    """

def get_value(cls, path, key):
        for base in HKEYS:
            d = cls.read_values(base, path)
            if d and key in d:
                return d[key]
        raise KeyError(key)
    get_value = classmethod(get_value)

def read_keys(cls, base, key):
        """Return list of registry keys."""
        try:
            handle = RegOpenKeyEx(base, key)
        except RegError:
            return None
        L = []
        i = 0
        while True:
            try:
                k = RegEnumKey(handle, i)
            except RegError:
                break
            L.append(k)
            i += 1
        return L
    read_keys = classmethod(read_keys)

def read_values(cls, base, key):
        """Return dict of registry keys and values.

All names are converted to lowercase.
        """
        try:
            handle = RegOpenKeyEx(base, key)
        except RegError:
            return None
        d = {}
        i = 0
        while True:
            try:
                name, value, type = RegEnumValue(handle, i)
            except RegError:
                break
            name = name.lower()
            d[cls.convert_mbcs(name)] = cls.convert_mbcs(value)
            i += 1
        return d
    read_values = classmethod(read_values)

def convert_mbcs(s):
        dec = getattr(s, "decode", None)
        if dec is not None:
            try:
                s = dec("mbcs")
            except UnicodeError:
                pass
        return s
    convert_mbcs = staticmethod(convert_mbcs)

class MacroExpander:

def __init__(self, version):
        self.macros = {}
        self.vsbase = VS_BASE % version
        self.load_macros(version)

def set_macro(self, macro, path, key):
        self.macros["$(%s)" % macro] = Reg.get_value(path, key)

def load_macros(self, version):
        self.set_macro("VCInstallDir", self.vsbase + r"\Setup\VC", "productdir")
        self.set_macro("VSInstallDir", self.vsbase + r"\Setup\VS", "productdir")
        self.set_macro("FrameworkDir", NET_BASE, "installroot")
        try:
            if version >= 8.0:
                self.set_macro("FrameworkSDKDir", NET_BASE,
                               "sdkinstallrootv2.0")
            else:
                raise KeyError("sdkinstallrootv2.0")
        except KeyError:
            raise DistutilsPlatformError(
            """Python was built with Visual Studio 2008;
extensions must be built with a compiler than can generate compatible binaries.
Visual Studio 2008 was not found on this system. If you have Cygwin installed,
you can try compiling with MingW32, by passing "-c mingw32" to setup.py.""")

if version >= 9.0:
            self.set_macro("FrameworkVersion", self.vsbase, "clr version")
            self.set_macro("WindowsSdkDir", WINSDK_BASE, "currentinstallfolder")
        else:
            p = r"Software\Microsoft\NET Framework Setup\Product"
            for base in HKEYS:
                try:
                    h = RegOpenKeyEx(base, p)
                except RegError:
                    continue
                key = RegEnumKey(h, 0)
                d = Reg.get_value(base, r"%s\%s" % (p, key))
                self.macros["$(FrameworkVersion)"] = d["version"]

def sub(self, s):
        for k, v in self.macros.items():
            s = s.replace(k, v)
        return s

def get_build_version():
    """Return the version of MSVC that was used to build Python.

For Python 2.3 and up, the version number is included in
    sys.version.  For earlier versions, assume the compiler is MSVC 6.
    """
    prefix = "MSC v."
    i = sys.version.find(prefix)
    if i == -1:
        return 6
    i = i + len(prefix)
    s, rest = sys.version[i:].split(" ", 1)
    majorVersion = int(s[:-2]) - 6
    minorVersion = int(s[2:3]) / 10.0
    # I don't think paths are affected by minor version in version 6
    if majorVersion == 6:
        minorVersion = 0
    if majorVersion >= 6:
        return majorVersion + minorVersion
    # else we don't know what version of the compiler this is
    return None

def normalize_and_reduce_paths(paths):
    """Return a list of normalized paths with duplicates removed.

def removeDuplicates(variable):
    """Remove duplicate values of an environment variable.
    """
    oldList = variable.split(os.pathsep)
    newList = []
    for i in oldList:
        if i not in newList:
            newList.append(i)
    newVariable = os.pathsep.join(newList)
    return newVariable

def find_vcvarsall(version):
    """Find the vcvarsall.bat file

At first it tries to find the productdir of VS 2008 in the registry. If
    that fails it falls back to the VS90COMNTOOLS env var.
    """
    vsbase = VS_BASE % version
    try:
        productdir = Reg.get_value(r"%s\Setup\VC" % vsbase,
                                   "productdir")
    except KeyError:
        productdir = None

# trying Express edition
    if productdir is None:
        vsbase = VSEXPRESS_BASE % version
        try:
            productdir = Reg.get_value(r"%s\Setup\VC" % vsbase,
                                       "productdir")
        except KeyError:
            productdir = None
            log.debug("Unable to find productdir in registry")

if not productdir or not os.path.isdir(productdir):
        toolskey = "VS%0.f0COMNTOOLS" % version
        toolsdir = os.environ.get(toolskey, None)

if toolsdir and os.path.isdir(toolsdir):
            productdir = os.path.join(toolsdir, os.pardir, os.pardir, "VC")
            productdir = os.path.abspath(productdir)
            if not os.path.isdir(productdir):
                log.debug("%s is not a valid directory" % productdir)
                return None
        else:
            log.debug("Env var %s is not set or invalid" % toolskey)
    if not productdir:
        log.debug("No productdir found")
        return None
    vcvarsall = os.path.join(productdir, "vcvarsall.bat")
    if os.path.isfile(vcvarsall):
        return vcvarsall
    log.debug("Unable to find vcvarsall.bat")
    return None

def query_vcvarsall(version, arch="x86"):
    """Launch vcvarsall.bat and read the settings from its environment
    """
    vcvarsall = find_vcvarsall(version)
    interesting = set(("include", "lib", "libpath", "path"))
    result = {}

if vcvarsall is None:
        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
    log.debug("Calling 'vcvarsall.bat %s' (version=%s)", arch, version)
    popen = subprocess.Popen('"%s" %s & set' % (vcvarsall, arch),
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
    try:
        stdout, stderr = popen.communicate()
        if popen.wait() != 0:
            raise DistutilsPlatformError(stderr.decode("mbcs"))

stdout = stdout.decode("mbcs")
        for line in stdout.split("\n"):
            line = Reg.convert_mbcs(line)
            if '=' not in line:
                continue
            line = line.strip()
            key, value = line.split('=', 1)
            key = key.lower()
            if key in interesting:
                if value.endswith(os.pathsep):
                    value = value[:-1]
                result[key] = removeDuplicates(value)

finally:
        popen.stdout.close()
        popen.stderr.close()

if len(result) != len(interesting):
        raise ValueError(str(list(result.keys())))

return result

# More globals
VERSION = get_build_version()
if VERSION < 8.0:
    raise DistutilsPlatformError("VC %0.1f is not supported by this module" % VERSION)
# MACROS = MacroExpander(VERSION)

class MSVCCompiler(CCompiler) :
    """Concrete class that implements an interface to Microsoft Visual C++,
       as defined by the CCompiler abstract class."""

compiler_type = 'msvc'

def __init__(self, verbose=0, dry_run=0, force=0):
        CCompiler.__init__ (self, verbose, dry_run, force)
        self.__version = VERSION
        self.__root = r"Software\Microsoft\VisualStudio"
        # self.__macros = MACROS
        self.__paths = []
        # target platform (.plat_name is consistent with 'bdist')
        self.plat_name = None
        self.__arch = None # deprecated name
        self.initialized = False

def initialize(self, plat_name=None):
        # multi-init means we would need to check platform same each time...
        assert not self.initialized, "don't init multiple times"
        if plat_name is None:
            plat_name = get_platform()
        # sanity check for platforms to prevent obscure errors later.
        ok_plats = 'win32', 'win-amd64', 'win-ia64'
        if plat_name not in ok_plats:
            raise DistutilsPlatformError("--plat-name must be one of %s" %
                                         (ok_plats,))

if "DISTUTILS_USE_SDK" in os.environ and "MSSdk" in os.environ and self.find_exe("cl.exe"):
            # Assume that the SDK set up everything alright; don't try to be
            # smarter
            self.cc = "cl.exe"
            self.linker = "link.exe"
            self.lib = "lib.exe"
            self.rc = "rc.exe"
            self.mc = "mc.exe"
        else:
            # On x86, 'vcvars32.bat amd64' creates an env that doesn't work;
            # to cross compile, you use 'x86_amd64'.
            # On AMD64, 'vcvars32.bat amd64' is a native build env; to cross
            # compile use 'x86' (ie, it runs the x86 compiler directly)
            # No idea how itanium handles this, if at all.
            if plat_name == get_platform() or plat_name == 'win32':
                # native build or cross-compile to win32
                plat_spec = PLAT_TO_VCVARS[plat_name]
            else:
                # cross compile from win32 -> some 64bit
                plat_spec = PLAT_TO_VCVARS[get_platform()] + '_' + \
                            PLAT_TO_VCVARS[plat_name]

vc_env = query_vcvarsall(VERSION, plat_spec)

# take care to only use strings in the environment.
            self.__paths = vc_env['path'].encode('mbcs').split(os.pathsep)
            os.environ['lib'] = vc_env['lib'].encode('mbcs')
            os.environ['include'] = vc_env['include'].encode('mbcs')

if len(self.__paths) == 0:
                raise DistutilsPlatformError("Python was built with %s, "
                       "and extensions need to be built with the same "
                       "version of the compiler, but it isn't installed."
                       % self.__product)

self.cc = self.find_exe("cl.exe")
            self.linker = self.find_exe("link.exe")
            self.lib = self.find_exe("lib.exe")
            self.rc = self.find_exe("rc.exe")   # resource compiler
            self.mc = self.find_exe("mc.exe")   # message compiler
            #self.set_path_env_var('lib')
            #self.set_path_env_var('include')

# extend the MSVC path with the current path
        try:
            for p in os.environ['path'].split(';'):
                self.__paths.append(p)
        except KeyError:
            pass
        self.__paths = normalize_and_reduce_paths(self.__paths)
        os.environ['path'] = ";".join(self.__paths)

self.preprocess_options = None
        if self.__arch == "x86":
            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3',
                                     '/DNDEBUG']
            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3',
                                          '/Z7', '/D_DEBUG']
        else:
            # Win64
            self.compile_options = [ '/nologo', '/Ox', '/MD', '/W3', '/GS-' ,
                                     '/DNDEBUG']
            self.compile_options_debug = ['/nologo', '/Od', '/MDd', '/W3', '/GS-',
                                          '/Z7', '/D_DEBUG']

self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
        if self.__version >= 7:
            self.ldflags_shared_debug = [
                '/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG'
                ]
        self.ldflags_static = [ '/nologo']

self.initialized = True

# -- Worker methods ------------------------------------------------

def object_filenames(self,
                         source_filenames,
                         strip_dir=0,
                         output_dir=''):
        # Copied from ccompiler.py, extended to return .res as 'object'-file
        # for .rc input file
        if output_dir is None: output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            (base, ext) = os.path.splitext (src_name)
            base = os.path.splitdrive(base)[1] # Chop off the drive
            base = base[os.path.isabs(base):]  # If abs, chop off leading /
            if ext not in self.src_extensions:
                # Better to raise an exception instead of silently continuing
                # and later complain about sources and targets having
                # different lengths
                raise CompileError ("Don't know how to compile %s" % src_name)
            if strip_dir:
                base = os.path.basename (base)
            if ext in self._rc_extensions:
                obj_names.append (os.path.join (output_dir,
                                                base + self.res_extension))
            elif ext in self._mc_extensions:
                obj_names.append (os.path.join (output_dir,
                                                base + self.res_extension))
            else:
                obj_names.append (os.path.join (output_dir,
                                                base + self.obj_extension))
        return obj_names

def compile(self, sources,
                output_dir=None, macros=None, include_dirs=None, debug=0,
                extra_preargs=None, extra_postargs=None, depends=None):

if not self.initialized:
            self.initialize()
        compile_info = self._setup_compile(output_dir, macros, include_dirs,
                                           sources, depends, extra_postargs)
        macros, objects, extra_postargs, pp_opts, build = compile_info

if ext in self._c_extensions:
                input_opt = "/Tc" + src
            elif ext in self._cpp_extensions:
                input_opt = "/Tp" + src
            elif ext in self._rc_extensions:
                # compile .RC to .RES file
                input_opt = src
                output_opt = "/fo" + obj
                try:
                    self.spawn([self.rc] + pp_opts +
                               [output_opt] + [input_opt])
                except DistutilsExecError, msg:
                    raise CompileError(msg)
                continue
            elif ext in self._mc_extensions:
                # Compile .MC to .RC file to .RES file.
                #   * '-h dir' specifies the directory for the
                #     generated include file
                #   * '-r dir' specifies the target directory of the
                #     generated RC file and the binary message resource
                #     it includes
                #
                # For now (since there are no options to change this),
                # we use the source-directory for the include file and
                # the build directory for the RC file and message
                # resources. This works at least for win32all.
                h_dir = os.path.dirname(src)
                rc_dir = os.path.dirname(obj)
                try:
                    # first compile .MC to .RC and .H file
                    self.spawn([self.mc] +
                               ['-h', h_dir, '-r', rc_dir] + [src])
                    base, _ = os.path.splitext (os.path.basename (src))
                    rc_file = os.path.join (rc_dir, base + '.rc')
                    # then compile .RC to .RES file
                    self.spawn([self.rc] +
                               ["/fo" + obj] + [rc_file])

except DistutilsExecError, msg:
                    raise CompileError(msg)
                continue
            else:
                # how to handle this file?
                raise CompileError("Don't know how to compile %s to %s"
                                   % (src, obj))

output_opt = "/Fo" + obj
            try:
                self.spawn([self.cc] + compile_opts + pp_opts +
                           [input_opt, output_opt] +
                           extra_postargs)
            except DistutilsExecError, msg:
                raise CompileError(msg)

return objects

def create_static_lib(self,
                          objects,
                          output_libname,
                          output_dir=None,
                          debug=0,
                          target_lang=None):

if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        output_filename = self.library_filename(output_libname,
                                                output_dir=output_dir)

if self._need_link(objects, output_filename):
            lib_args = objects + ['/OUT:' + output_filename]
            if debug:
                pass # XXX what goes here?
            try:
                self.spawn([self.lib] + lib_args)
            except DistutilsExecError, msg:
                raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

def link(self,
             target_desc,
             objects,
             output_filename,
             output_dir=None,
             libraries=None,
             library_dirs=None,
             runtime_library_dirs=None,
             export_symbols=None,
             debug=0,
             extra_preargs=None,
             extra_postargs=None,
             build_temp=None,
             target_lang=None):

if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        fixed_args = self._fix_lib_args(libraries, library_dirs,
                                        runtime_library_dirs)
        (libraries, library_dirs, runtime_library_dirs) = fixed_args

if runtime_library_dirs:
            self.warn ("I don't know what to do with 'runtime_library_dirs': "
                       + str (runtime_library_dirs))

lib_opts = gen_lib_options(self,
                                   library_dirs, runtime_library_dirs,
                                   libraries)
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

if self._need_link(objects, output_filename):
            if target_desc == CCompiler.EXECUTABLE:
                if debug:
                    ldflags = self.ldflags_shared_debug[1:]
                else:
                    ldflags = self.ldflags_shared[1:]
            else:
                if debug:
                    ldflags = self.ldflags_shared_debug
                else:
                    ldflags = self.ldflags_shared

export_opts = []
            for sym in (export_symbols or []):
                export_opts.append("/EXPORT:" + sym)

ld_args = (ldflags + lib_opts + export_opts +
                       objects + ['/OUT:' + output_filename])

# The MSVC linker generates .lib and .exp files, which cannot be
            # suppressed by any linker switches. The .lib files may even be
            # needed! Make sure they are generated in the temporary build
            # directory. Since they have different names for debug and release
            # builds, they can go into the same directory.
            build_temp = os.path.dirname(objects[0])
            if export_symbols is not None:
                (dll_name, dll_ext) = os.path.splitext(
                    os.path.basename(output_filename))
                implib_file = os.path.join(
                    build_temp,
                    self.library_filename(dll_name))
                ld_args.append ('/IMPLIB:' + implib_file)

self.manifest_setup_ldargs(output_filename, build_temp, ld_args)

if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

self.mkpath(os.path.dirname(output_filename))
            try:
                self.spawn([self.linker] + ld_args)
            except DistutilsExecError, msg:
                raise LinkError(msg)

# embed the manifest
            # XXX - this is somewhat fragile - if mt.exe fails, distutils
            # will still consider the DLL up-to-date, but it will not have a
            # manifest.  Maybe we should link to a temp file?  OTOH, that
            # implies a build environment error that shouldn't go undetected.
            mfinfo = self.manifest_get_embed_info(target_desc, ld_args)
            if mfinfo is not None:
                mffilename, mfid = mfinfo
                out_arg = '-outputresource:%s;%s' % (output_filename, mfid)
                try:
                    self.spawn(['mt.exe', '-nologo', '-manifest',
                                mffilename, out_arg])
                except DistutilsExecError, msg:
                    raise LinkError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

def manifest_setup_ldargs(self, output_filename, build_temp, ld_args):
        # If we need a manifest at all, an embedded manifest is recommended.
        # See MSDN article titled
        # "How to: Embed a Manifest Inside a C/C++ Application"
        # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
        # Ask the linker to generate the manifest in the temp dir, so
        # we can check it, and possibly embed it, later.
        temp_manifest = os.path.join(
                build_temp,
                os.path.basename(output_filename) + ".manifest")
        ld_args.append('/MANIFESTFILE:' + temp_manifest)

def manifest_get_embed_info(self, target_desc, ld_args):
        # If a manifest should be embedded, return a tuple of
        # (manifest_filename, resource_id).  Returns None if no manifest
        # should be embedded.  See http://bugs.python.org/issue7833 for why
        # we want to avoid any manifest for extension modules if we can)
        for arg in ld_args:
            if arg.startswith("/MANIFESTFILE:"):
                temp_manifest = arg.split(":", 1)[1]
                break
        else:
            # no /MANIFESTFILE so nothing to do.
            return None
        if target_desc == CCompiler.EXECUTABLE:
            # by default, executables always get the manifest with the
            # CRT referenced.
            mfid = 1
        else:
            # Extension modules try and avoid any manifest if possible.
            mfid = 2
            temp_manifest = self._remove_visual_c_ref(temp_manifest)
        if temp_manifest is None:
            return None
        return temp_manifest, mfid

def _remove_visual_c_ref(self, manifest_file):
        try:
            # Remove references to the Visual C runtime, so they will
            # fall through to the Visual C dependency of Python.exe.
            # This way, when installed for a restricted user (e.g.
            # runtimes are not in WinSxS folder, but in Python's own
            # folder), the runtimes do not need to be in every folder
            # with .pyd's.
            # Returns either the filename of the modified manifest or
            # None if no manifest should be embedded.
            manifest_f = open(manifest_file)
            try:
                manifest_buf = manifest_f.read()
            finally:
                manifest_f.close()
            pattern = re.compile(
                r"""<assemblyIdentity.*?name=("|')Microsoft\."""\
                r"""VC\d{2}\.CRT("|').*?(/>|</assemblyIdentity>)""",
                re.DOTALL)
            manifest_buf = re.sub(pattern, "", manifest_buf)
            pattern = "<dependentAssembly>\s*</dependentAssembly>"
            manifest_buf = re.sub(pattern, "", manifest_buf)
            # Now see if any other assemblies are referenced - if not, we
            # don't want a manifest embedded.
            pattern = re.compile(
                r"""<assemblyIdentity.*?name=(?:"|')(.+?)(?:"|')"""
                r""".*?(?:/>|</assemblyIdentity>)""", re.DOTALL)
            if re.search(pattern, manifest_buf) is None:
                return None

manifest_f = open(manifest_file, 'w')
            try:
                manifest_f.write(manifest_buf)
                return manifest_file
            finally:
                manifest_f.close()
        except IOError:
            pass

# -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

def library_dir_option(self, dir):
        return "/LIBPATH:" + dir

def runtime_library_dir_option(self, dir):
        raise DistutilsPlatformError(
              "don't know how to set runtime library search path for MSVC++")

def library_option(self, lib):
        return self.library_filename(lib)

def find_library_file(self, dirs, lib, debug=0):
        # Prefer a debugging library if found (and requested), but deal
        # with it if we don't have one.
        if debug:
            try_names = [lib + "_d", lib]
        else:
            try_names = [lib]
        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename (name))
                if os.path.exists(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None

# Helper methods for using the MSVC registry settings

def find_exe(self, exe):
        """Return path to an MSVC executable program.

# didn't find it; try existing path
        for p in os.environ['Path'].split(';'):
            fn = os.path.join(os.path.abspath(p),exe)
            if os.path.isfile(fn):
                return fn

return exe
msvccompiler.pyo000064400000042165151702014350010006 0ustar00�
{fc@sdZdZddlZddlZddlZddlmZmZmZm	Z	m
Z
ddlmZm
Z
ddlmZdZy@ddlZdZeZejZejZejZejZWn~ek
rDyLddlZddlZdZeZejZejZejZejZWnek
r@ejd	�nXnXerlejej ej!ej"fZ#nd
�Z$d�Z%d�Z&d
fd��YZ'd�Z(d�Z)d�Z*defd��YZ+e(�dkrej,d�e+Z-ddl.m+Z+ddl.m'Z'ndS(s�distutils.msvccompiler

cCs�yt||�}Wntk
r'dSXi}d}xayt||�\}}}Wntk
rgPnX|j�}t|�|t|�<|d}q7W|S(sXReturn dict of registry keys and values.

All names are converted to lowercase.
    iiN(RR	R
tRegEnumValuetlowertconvert_mbcs(R
RRtdRtnametvaluettype((s./usr/lib64/python2.7/distutils/msvccompiler.pytread_valuesMs

#
$$#

cCs�xH|jD]=}tjjtjj|�|�}tjj|�r
|Sq
WxXtjtjdd�D]=}tjjtjj|�|�}tjj|�re|SqeW|S(s�Return path to an MSVC executable program.

cCsS|dkr|jd�}n|j|�}|rOtj|d�tj|<ndS(s�Set environment variable 'name' to an MSVC path type value.

.		
	��
spawn.py000064400000020710151702014350006244 0ustar00"""distutils.spawn

__revision__ = "$Id$"

import sys
import os

from distutils.errors import DistutilsPlatformError, DistutilsExecError
from distutils.debug import DEBUG
from distutils import log

def spawn(cmd, search_path=1, verbose=0, dry_run=0):
    """Run another program, specified as a command list 'cmd', in a new process.

Raise DistutilsExecError if running the program fails in any way; just
    return on success.
    """
    # cmd is documented as a list, but just in case some code passes a tuple
    # in, protect our %-formatting code against horrible death
    cmd = list(cmd)
    if os.name == 'posix':
        _spawn_posix(cmd, search_path, dry_run=dry_run)
    elif os.name == 'nt':
        _spawn_nt(cmd, search_path, dry_run=dry_run)
    elif os.name == 'os2':
        _spawn_os2(cmd, search_path, dry_run=dry_run)
    else:
        raise DistutilsPlatformError, \
              "don't know how to spawn programs on platform '%s'" % os.name

def _nt_quote_args(args):
    """Quote command-line arguments for DOS/Windows conventions.

Just wraps every argument which contains blanks in double quotes, and
    returns a new argument list.
    """
    # XXX this doesn't seem very robust to me -- but if the Windows guys
    # say it'll work, I guess I'll have to accept it.  (What if an arg
    # contains quotes?  What other magic characters, other than spaces,
    # have to be escaped?  Is there an escaping mechanism other than
    # quoting?)
    for i, arg in enumerate(args):
        if ' ' in arg:
            args[i] = '"%s"' % arg
    return args

def _spawn_nt(cmd, search_path=1, verbose=0, dry_run=0):
    executable = cmd[0]
    cmd = _nt_quote_args(cmd)
    if search_path:
        # either we find one or it stays the same
        executable = find_executable(executable) or executable
    log.info(' '.join([executable] + cmd[1:]))
    if not dry_run:
        # spawn for NT requires a full path to the .exe
        try:
            rc = os.spawnv(os.P_WAIT, executable, cmd)
        except OSError, exc:
            # this seems to happen when the command isn't found
            if not DEBUG:
                cmd = executable
            raise DistutilsExecError, \
                  "command %r failed: %s" % (cmd, exc[-1])
        if rc != 0:
            # and this reflects the command running but failing
            if not DEBUG:
                cmd = executable
            raise DistutilsExecError, \
                  "command %r failed with exit status %d" % (cmd, rc)

def _spawn_os2(cmd, search_path=1, verbose=0, dry_run=0):
    executable = cmd[0]
    if search_path:
        # either we find one or it stays the same
        executable = find_executable(executable) or executable
    log.info(' '.join([executable] + cmd[1:]))
    if not dry_run:
        # spawnv for OS/2 EMX requires a full path to the .exe
        try:
            rc = os.spawnv(os.P_WAIT, executable, cmd)
        except OSError, exc:
            # this seems to happen when the command isn't found
            if not DEBUG:
                cmd = executable
            raise DistutilsExecError, \
                  "command %r failed: %s" % (cmd, exc[-1])
        if rc != 0:
            # and this reflects the command running but failing
            if not DEBUG:
                cmd = executable
            log.debug("command %r failed with exit status %d" % (cmd, rc))
            raise DistutilsExecError, \
                  "command %r failed with exit status %d" % (cmd, rc)

if sys.platform == 'darwin':
    from distutils import sysconfig
    _cfg_target = None
    _cfg_target_split = None

def _spawn_posix(cmd, search_path=1, verbose=0, dry_run=0):
    log.info(' '.join(cmd))
    if dry_run:
        return
    executable = cmd[0]
    exec_fn = search_path and os.execvp or os.execv
    env = None
    if sys.platform == 'darwin':
        global _cfg_target, _cfg_target_split
        if _cfg_target is None:
            _cfg_target = sysconfig.get_config_var(
                                  'MACOSX_DEPLOYMENT_TARGET') or ''
            if _cfg_target:
                _cfg_target_split = [int(x) for x in _cfg_target.split('.')]
        if _cfg_target:
            # ensure that the deployment target of build process is not less
            # than that used when the interpreter was built. This ensures
            # extension modules are built with correct compatibility values
            cur_target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', _cfg_target)
            if _cfg_target_split > [int(x) for x in cur_target.split('.')]:
                my_msg = ('$MACOSX_DEPLOYMENT_TARGET mismatch: '
                          'now "%s" but "%s" during configure'
                                % (cur_target, _cfg_target))
                raise DistutilsPlatformError(my_msg)
            env = dict(os.environ,
                       MACOSX_DEPLOYMENT_TARGET=cur_target)
            exec_fn = search_path and os.execvpe or os.execve
    pid = os.fork()

if pid == 0:  # in the child
        try:
            if env is None:
                exec_fn(executable, cmd)
            else:
                exec_fn(executable, cmd, env)
        except OSError, e:
            if not DEBUG:
                cmd = executable
            sys.stderr.write("unable to execute %r: %s\n" %
                             (cmd, e.strerror))
            os._exit(1)

if not DEBUG:
            cmd = executable
        sys.stderr.write("unable to execute %r for unknown reasons" % cmd)
        os._exit(1)
    else:   # in the parent
        # Loop until the child either exits or is terminated by a signal
        # (ie. keep waiting if it's merely stopped)
        while 1:
            try:
                pid, status = os.waitpid(pid, 0)
            except OSError, exc:
                import errno
                if exc.errno == errno.EINTR:
                    continue
                if not DEBUG:
                    cmd = executable
                raise DistutilsExecError, \
                      "command %r failed: %s" % (cmd, exc[-1])
            if os.WIFSIGNALED(status):
                if not DEBUG:
                    cmd = executable
                raise DistutilsExecError, \
                      "command %r terminated by signal %d" % \
                      (cmd, os.WTERMSIG(status))

elif os.WIFEXITED(status):
                exit_status = os.WEXITSTATUS(status)
                if exit_status == 0:
                    return   # hey, it succeeded!
                else:
                    if not DEBUG:
                        cmd = executable
                    raise DistutilsExecError, \
                          "command %r failed with exit status %d" % \
                          (cmd, exit_status)

elif os.WIFSTOPPED(status):
                continue

else:
                if not DEBUG:
                    cmd = executable
                raise DistutilsExecError, \
                      "unknown error executing %r: termination status %d" % \
                      (cmd, status)

def find_executable(executable, path=None):
    """Tries to find 'executable' in the directories listed in 'path'.

A string listing directories separated by 'os.pathsep'; defaults to
    os.environ['PATH'].  Returns the complete filename or None if not found.
    """
    if path is None:
        path = os.environ.get('PATH', os.defpath)

paths = path.split(os.pathsep)
    base, ext = os.path.splitext(executable)

if (sys.platform == 'win32' or os.name == 'os2') and (ext != '.exe'):
        executable = executable + '.exe'

if not os.path.isfile(executable):
        for p in paths:
            f = os.path.join(p, executable)
            if os.path.isfile(f):
                # the file exists, we have a shot at spawn working
                return f
        return None
    else:
        return executable
spawn.pyo000064400000014433151702014350006430 0ustar00�
{fc@s�dZdZddlZddlZddlmZmZddlmZddl	m
Z
dddd	�Zd
�Zdddd�Z
dddd�Zejd
kr�ddl	mZdadandddd�Zdd�ZdS(s�distutils.spawn

(t__doc__t__revision__R*R	tdistutils.errorsRRtdistutils.debugRt	distutilsRRRRR
R+R#R)R,R0RR(((s'/usr/lib64/python2.7/distutils/spawn.pyt<module>s 		Xsysconfig.py000064400000042453151702014350007130 0ustar00"""Provide access to Python's configuration information.  The specific
configuration variables available depend heavily on the platform and
configuration.  The values may be retrieved using
get_config_var(name), and the list of variables is available via
get_config_vars().keys().  Additional convenience functions are also
available.

Written by:   Fred L. Drake, Jr.
Email:        <fdrake@acm.org>
"""

__revision__ = "$Id$"

import os
import re
import string
import sys

from distutils.errors import DistutilsPlatformError

# These are needed in a couple of spots, so just compute them once.
PREFIX = os.path.normpath(sys.prefix)
EXEC_PREFIX = os.path.normpath(sys.exec_prefix)

# set for cross builds
if "_PYTHON_PROJECT_BASE" in os.environ:
    # this is the build directory, at least for posix
    project_base = os.path.normpath(os.environ["_PYTHON_PROJECT_BASE"])

def get_python_inc(plat_specific=0, prefix=None):
    """Return the directory containing installed Python header files.

If 'prefix' is supplied, use it instead of sys.prefix or
    sys.exec_prefix -- i.e., ignore 'plat_specific'.
    """
    if prefix is None:
        prefix = plat_specific and EXEC_PREFIX or PREFIX

if os.name == "posix":
        if python_build:
            if sys.executable:
                buildir = os.path.dirname(sys.executable)
            else:
                # sys.executable can be empty if argv[0] has been changed
                # and Python is unable to retrieve the real program name
                buildir = os.getcwd()
            if plat_specific:
                # python.h is located in the buildir
                inc_dir = buildir
            else:
                # the source dir is relative to the buildir
                srcdir = os.path.abspath(os.path.join(buildir,
                                         get_config_var('srcdir')))
                # Include is located in the srcdir
                inc_dir = os.path.join(srcdir, "Include")
            return inc_dir
        return os.path.join(prefix, "include",
            "python" + get_python_version() + (sys.pydebug and '-debug' or ''))
    elif os.name == "nt":
        return os.path.join(prefix, "include")
    elif os.name == "os2":
        return os.path.join(prefix, "Include")
    else:
        raise DistutilsPlatformError(
            "I don't know where Python installs its C header files "
            "on platform '%s'" % os.name)

def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
    """Return the directory containing the Python library (standard or
    site additions).

If 'prefix' is supplied, use it instead of sys.prefix or
    sys.exec_prefix -- i.e., ignore 'plat_specific'.
    """
    if prefix is None:
        prefix = plat_specific and EXEC_PREFIX or PREFIX

elif os.name == "os2":
        if standard_lib:
            return os.path.join(prefix, "Lib")
        else:
            return os.path.join(prefix, "Lib", "site-packages")

else:
        raise DistutilsPlatformError(
            "I don't know where Python installs its library "
            "on platform '%s'" % os.name)

def customize_compiler(compiler):
    """Do any platform-specific customization of a CCompiler instance.

compiler.shared_lib_extension = so_ext

def parse_config_h(fp, g=None):
    """Parse a config.h-style file.

def parse_makefile(fn, g=None):
    """Parse a Makefile-style file.

if g is None:
        g = {}
    done = {}
    notdone = {}

fp.close()

# strip spurious spaces
    for k, v in done.items():
        if isinstance(v, str):
            done[k] = v.strip()

# save the results in the global dictionary
    g.update(done)
    return g

_config_vars = None

# XXX hmmm.. a normal install puts include files here
    g['INCLUDEPY'] = get_python_inc(plat_specific=0)

g['SO'] = '.pyd'
    g['EXE'] = ".exe"
    g['VERSION'] = get_python_version().replace(".", "")
    g['BINDIR'] = os.path.dirname(os.path.abspath(sys.executable))

global _config_vars
    _config_vars = g

# XXX hmmm.. a normal install puts include files here
    g['INCLUDEPY'] = get_python_inc(plat_specific=0)

g['SO'] = '.pyd'
    g['EXE'] = ".exe"

global _config_vars
    _config_vars = g

if args:
        vals = []
        for name in args:
            vals.append(_config_vars.get(name))
        return vals
    else:
        return _config_vars

def get_config_var(name):
    """Return the value of a single variable using the dictionary
    returned by 'get_config_vars()'.  Equivalent to
    get_config_vars().get(name)
    """
    return get_config_vars().get(name)
sysconfig.pyo000064400000032134151702014350007302 0ustar00�
�fc@s�dZdZddlZddlZddlZddlZddlmZejj	ej
�Zejj	ej�Z
ejr�ejjejjej��Znej�Zejdkr�dedj�kr�ejjejjeejj��ZnejdkrVded	j�krVejjejjeejjejj��Znejdkr�d
edj�kr�ejjejjeejjejj��Zndejkr�ejj	ejd�Znd
�Ze�Zd�Zddd�Zdddd�Zd�Zd�Zd�Z dd�Z!ej"d�Z#ej"d�Z$ej"d�Z%dd�Z&d�Z'da(d�Z)d�Z*d�Z+d�Z,d�Z-dS( s�Provide access to Python's configuration information.  The specific
configuration variables available depend heavily on the platform and
configuration.  The values may be retrieved using
get_config_var(name), and the list of variables is available via
get_config_vars().keys().  Additional convenience functions are also
available.

cCst�j|�S(s�Return the value of a single variable using the dictionary
    returned by 'get_config_vars()'.  Equivalent to
    get_config_vars().get(name)
    (RIR�(R((s+/usr/lib64/python2.7/distutils/sysconfig.pyR!�s(.t__doc__t__revision__RRatstringRtdistutils.errorsRRtnormpathR$RR�RRRR R	RRtlowerRtpardirRJR
RRRR'R-RGR\R`RpRbRwR{R}R�R�RHR�R�R�RIR!(((s+/usr/lib64/python2.7/distutils/sysconfig.pyt<module>
sR	$%*%%			,3	J		S						&text_file.py000064400000030214151702014350007077 0ustar00"""text_file

provides the TextFile class, which gives an interface to text files
that (optionally) takes care of stripping comments, ignoring blank
lines, and joining lines with backslashes."""

__revision__ = "$Id$"

import sys

class TextFile:

"""Provides a file-like object that takes care of all the things you
       commonly want to do when processing a text file that has some
       line-by-line syntax: strip comments (as long as "#" is your
       comment character), skip blank lines, join adjacent lines by
       escaping the newline (ie. backslash at end of line), strip
       leading and/or trailing whitespace.  All of these are optional
       and independently controllable.

Constructor is called as:

TextFile (filename=None, file=None, **options)

default_options = { 'strip_comments': 1,
                        'skip_blanks':    1,
                        'lstrip_ws':      0,
                        'rstrip_ws':      1,
                        'join_lines':     0,
                        'collapse_join':  0,
                      }

def __init__ (self, filename=None, file=None, **options):
        """Construct a new TextFile object.  At least one of 'filename'
           (a string) and 'file' (a file-like object) must be supplied.
           They keyword argument options are described above and affect
           the values returned by 'readline()'."""

if filename is None and file is None:
            raise RuntimeError, \
                  "you must supply either or both of 'filename' and 'file'"

# set values for all options -- either from client option hash
        # or fallback to default_options
        for opt in self.default_options.keys():
            if opt in options:
                setattr (self, opt, options[opt])

else:
                setattr (self, opt, self.default_options[opt])

# sanity check client option hash
        for opt in options.keys():
            if opt not in self.default_options:
                raise KeyError, "invalid TextFile option '%s'" % opt

if file is None:
            self.open (filename)
        else:
            self.filename = filename
            self.file = file
            self.current_line = 0       # assuming that file is at BOF!

# 'linebuf' is a stack of lines that will be emptied before we
        # actually read from the file; it's only populated by an
        # 'unreadline()' operation
        self.linebuf = []

def open (self, filename):
        """Open a new file named 'filename'.  This overrides both the
           'filename' and 'file' arguments to the constructor."""

self.filename = filename
        self.file = open (self.filename, 'r')
        self.current_line = 0

def close (self):
        """Close the current file and forget everything we know about it
           (filename, current line number)."""
        file = self.file
        self.file = None
        self.filename = None
        self.current_line = None
        file.close()

def gen_error (self, msg, line=None):
        outmsg = []
        if line is None:
            line = self.current_line
        outmsg.append(self.filename + ", ")
        if isinstance(line, (list, tuple)):
            outmsg.append("lines %d-%d: " % tuple (line))
        else:
            outmsg.append("line %d: " % line)
        outmsg.append(str(msg))
        return ''.join(outmsg)

def error (self, msg, line=None):
        raise ValueError, "error: " + self.gen_error(msg, line)

def warn (self, msg, line=None):
        """Print (to stderr) a warning message tied to the current logical
           line in the current file.  If the current logical line in the
           file spans multiple physical lines, the warning refers to the
           whole range, eg. "lines 3-5".  If 'line' supplied, it overrides
           the current line number; it may be a list or tuple to indicate a
           range of physical lines, or an integer for a single physical
           line."""
        sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")

def readline (self):
        """Read and return a single logical line from the current file (or
           from an internal buffer if lines have previously been "unread"
           with 'unreadline()').  If the 'join_lines' option is true, this
           may involve reading multiple physical lines concatenated into a
           single string.  Updates the current line number, so calling
           'warn()' after 'readline()' emits a warning about the physical
           line(s) just read.  Returns None on end-of-file, since the empty
           string can occur if 'rstrip_ws' is true but 'strip_blanks' is
           not."""

# If any "unread" lines waiting in 'linebuf', return the top
        # one.  (We don't actually buffer read-ahead data -- lines only
        # get put in 'linebuf' if the client explicitly does an
        # 'unreadline()'.
        if self.linebuf:
            line = self.linebuf[-1]
            del self.linebuf[-1]
            return line

buildup_line = ''

while 1:
            # read the line, make it None if EOF
            line = self.file.readline()
            if line == '': line = None

if self.strip_comments and line:

# Look for the first "#" in the line.  If none, never
                # mind.  If we find one and it's the first character, or
                # is not preceded by "\", then it starts a comment --
                # strip the comment, strip whitespace before it, and
                # carry on.  Otherwise, it's just an escaped "#", so
                # unescape it (and any other escaped "#"'s that might be
                # lurking in there) and otherwise leave the line alone.

pos = line.find("#")
                if pos == -1:           # no "#" -- no comments
                    pass

# It's definitely a comment -- either "#" is the first
                # character, or it's elsewhere and unescaped.
                elif pos == 0 or line[pos-1] != "\\":
                    # Have to preserve the trailing newline, because it's
                    # the job of a later step (rstrip_ws) to remove it --
                    # and if rstrip_ws is false, we'd better preserve it!
                    # (NB. this means that if the final line is all comment
                    # and has no trailing newline, we will think that it's
                    # EOF; I think that's OK.)
                    eol = (line[-1] == '\n') and '\n' or ''
                    line = line[0:pos] + eol

# If all that's left is whitespace, then skip line
                    # *now*, before we try to join it to 'buildup_line' --
                    # that way constructs like
                    #   hello \\
                    #   # comment that should be ignored
                    #   there
                    # result in "hello there".
                    if line.strip() == "":
                        continue

else:                   # it's an escaped "#"
                    line = line.replace("\\#", "#")

# did previous line end with a backslash? then accumulate
            if self.join_lines and buildup_line:
                # oops: end of file
                if line is None:
                    self.warn ("continuation line immediately precedes "
                               "end-of-file")
                    return buildup_line

if self.collapse_join:
                    line = line.lstrip()
                line = buildup_line + line

# careful: pay attention to line number when incrementing it
                if isinstance(self.current_line, list):
                    self.current_line[1] = self.current_line[1] + 1
                else:
                    self.current_line = [self.current_line,
                                         self.current_line+1]
            # just an ordinary line, read it as usual
            else:
                if line is None:        # eof
                    return None

# still have to be careful about incrementing the line number!
                if isinstance(self.current_line, list):
                    self.current_line = self.current_line[1] + 1
                else:
                    self.current_line = self.current_line + 1

# strip whitespace however the client wants (leading and
            # trailing, or one or the other, or neither)
            if self.lstrip_ws and self.rstrip_ws:
                line = line.strip()
            elif self.lstrip_ws:
                line = line.lstrip()
            elif self.rstrip_ws:
                line = line.rstrip()

# blank line (whether we rstrip'ed or not)? skip to next line
            # if appropriate
            if (line == '' or line == '\n') and self.skip_blanks:
                continue

if self.join_lines:
                if line[-1] == '\\':
                    buildup_line = line[:-1]
                    continue

if line[-2:] == '\\\n':
                    buildup_line = line[0:-2] + '\n'
                    continue

# well, I guess there's some actual content there: return it
            return line

# readline ()

def readlines (self):
        """Read and return the list of all logical lines remaining in the
           current file."""

lines = []
        while 1:
            line = self.readline()
            if line is None:
                return lines
            lines.append (line)

def unreadline (self, line):
        """Push 'line' (a string) onto an internal buffer that will be
           checked by future 'readline()' calls.  Handy for implementing
           a parser with line-at-a-time lookahead."""

self.linebuf.append (line)
text_file.pyo000064400000022053151702014350007260 0ustar00�
{fc@s/dZdZddlZddd��YZdS(s�text_file

Constructor is called as:

TextFile (filename=None, file=None, **options)

~	((R8t__revision__R%R(((s+/usr/lib64/python2.7/distutils/text_file.pyt<module>sunixccompiler.py000064400000033616151702014350010006 0ustar00"""distutils.unixccompiler

__revision__ = "$Id$"

import os, sys, re
from types import StringType, NoneType

from distutils import sysconfig
from distutils.dep_util import newer
from distutils.ccompiler import \
     CCompiler, gen_preprocess_options, gen_lib_options
from distutils.errors import \
     DistutilsExecError, CompileError, LibError, LinkError
from distutils import log

if sys.platform == 'darwin':
    import _osx_support

# XXX Things not currently handled:
#   * optimization/debug/warning flags; we just use whatever's in Python's
#     Makefile and live with it.  Is this adequate?  If not, we might
#     have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
#     SunCCompiler, and I suspect down that road lies madness.
#   * even if we don't know a warning flag from an optimization flag,
#     we need some way for outsiders to feed preprocessor/compiler/linker
#     flags in to us -- eg. a sysadmin might want to mandate certain flags
#     via a site config file, or a user might want to set something for
#     compiling this module distribution only via the setup.py command
#     line, whatever.  As long as these options come from something on the
#     current system, they can be as system-dependent as they like, and we
#     should just happily stuff them into the preprocessor/compiler/linker
#     options and carry on.

class UnixCCompiler(CCompiler):

compiler_type = 'unix'

# These are used by CCompiler in two places: the constructor sets
    # instance attributes 'preprocessor', 'compiler', etc. from them, and
    # 'set_executable()' allows any of these to be set.  The defaults here
    # are pretty generic; they will probably have to be set by an outsider
    # (eg. using information discovered by the sysconfig about building
    # Python extensions).
    executables = {'preprocessor' : None,
                   'compiler'     : ["cc"],
                   'compiler_so'  : ["cc"],
                   'compiler_cxx' : ["cc"],
                   'linker_so'    : ["cc", "-shared"],
                   'linker_exe'   : ["cc"],
                   'archiver'     : ["ar", "-cr"],
                   'ranlib'       : None,
                  }

if sys.platform[:6] == "darwin":
        executables['ranlib'] = ["ranlib"]

# Needed for the filename generation methods provided by the base
    # class, CCompiler.  NB. whoever instantiates/uses a particular
    # UnixCCompiler instance should set 'shared_lib_ext' -- we set a
    # reasonable common default here, but it's not necessarily used on all
    # Unices!

src_extensions = [".c",".C",".cc",".cxx",".cpp",".m"]
    obj_extension = ".o"
    static_lib_extension = ".a"
    shared_lib_extension = ".so"
    dylib_lib_extension = ".dylib"
    xcode_stub_lib_extension = ".tbd"
    static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
    xcode_stub_lib_format = dylib_lib_format
    if sys.platform == "cygwin":
        exe_extension = ".exe"

def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
        """Remove standard library path from rpath"""
        libraries, library_dirs, runtime_library_dirs = \
            CCompiler._fix_lib_args(self, libraries, library_dirs,
                                    runtime_library_dirs)
        libdir = sysconfig.get_config_var('LIBDIR')
        if runtime_library_dirs and (libdir in runtime_library_dirs):
            runtime_library_dirs.remove(libdir)
        return libraries, library_dirs, runtime_library_dirs

def preprocess(self, source,
                   output_file=None, macros=None, include_dirs=None,
                   extra_preargs=None, extra_postargs=None):
        ignore, macros, include_dirs = \
            self._fix_compile_args(None, macros, include_dirs)
        pp_opts = gen_preprocess_options(macros, include_dirs)
        pp_args = self.preprocessor + pp_opts
        if output_file:
            pp_args.extend(['-o', output_file])
        if extra_preargs:
            pp_args[:0] = extra_preargs
        if extra_postargs:
            pp_args.extend(extra_postargs)
        pp_args.append(source)

# We need to preprocess: either we're being forced to, or we're
        # generating output to stdout, or there's a target output file and
        # the source file is newer than the target (or the target doesn't
        # exist).
        if self.force or output_file is None or newer(source, output_file):
            if output_file:
                self.mkpath(os.path.dirname(output_file))
            try:
                self.spawn(pp_args)
            except DistutilsExecError, msg:
                raise CompileError, msg

def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        compiler_so = self.compiler_so
        if sys.platform == 'darwin':
            compiler_so = _osx_support.compiler_fixup(compiler_so,
                                                    cc_args + extra_postargs)
        try:
            self.spawn(compiler_so + cc_args + [src, '-o', obj] +
                       extra_postargs)
        except DistutilsExecError, msg:
            raise CompileError, msg

def create_static_lib(self, objects, output_libname,
                          output_dir=None, debug=0, target_lang=None):
        objects, output_dir = self._fix_object_args(objects, output_dir)

output_filename = \
            self.library_filename(output_libname, output_dir=output_dir)

if self._need_link(objects, output_filename):
            self.mkpath(os.path.dirname(output_filename))
            self.spawn(self.archiver +
                       [output_filename] +
                       objects + self.objects)

# Not many Unices required ranlib anymore -- SunOS 4.x is, I
            # think the only major Unix that does.  Maybe we need some
            # platform intelligence here to skip ranlib if it's not
            # needed -- or maybe Python's configure script took care of
            # it for us, hence the check for leading colon.
            if self.ranlib:
                try:
                    self.spawn(self.ranlib + [output_filename])
                except DistutilsExecError, msg:
                    raise LibError, msg
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

def link(self, target_desc, objects,
             output_filename, output_dir=None, libraries=None,
             library_dirs=None, runtime_library_dirs=None,
             export_symbols=None, debug=0, extra_preargs=None,
             extra_postargs=None, build_temp=None, target_lang=None):
        objects, output_dir = self._fix_object_args(objects, output_dir)
        libraries, library_dirs, runtime_library_dirs = \
            self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)

lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs,
                                   libraries)
        if type(output_dir) not in (StringType, NoneType):
            raise TypeError, "'output_dir' must be a string or None"
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

if self._need_link(objects, output_filename):
            ld_args = (objects + self.objects +
                       lib_opts + ['-o', output_filename])
            if debug:
                ld_args[:0] = ['-g']
            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)
            self.mkpath(os.path.dirname(output_filename))
            try:
                if target_desc == CCompiler.EXECUTABLE:
                    linker = self.linker_exe[:]
                else:
                    linker = self.linker_so[:]
                if target_lang == "c++" and self.compiler_cxx:
                    # skip over environment variable settings if /usr/bin/env
                    # is used to set up the linker's environment.
                    # This is needed on OSX. Note: this assumes that the
                    # normal and C++ compiler have the same environment
                    # settings.
                    i = 0
                    if os.path.basename(linker[0]) == "env":
                        i = 1
                        while '=' in linker[i]:
                            i = i + 1

linker[i] = self.compiler_cxx[i]

if sys.platform == 'darwin':
                    linker = _osx_support.compiler_fixup(linker, ld_args)

self.spawn(linker + ld_args)
            except DistutilsExecError, msg:
                raise LinkError, msg
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

# -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

def library_dir_option(self, dir):
        return "-L" + dir

def _is_gcc(self, compiler_name):
        return "gcc" in compiler_name or "g++" in compiler_name

def runtime_library_dir_option(self, dir):
        # XXX Hackish, at the very least.  See Python bug #445902:
        # http://sourceforge.net/tracker/index.php
        #   ?func=detail&aid=445902&group_id=5470&atid=105470
        # Linkers on different platforms need different options to
        # specify that directories need to be added to the list of
        # directories searched for dependencies when a dynamic library
        # is sought.  GCC has to be told to pass the -R option through
        # to the linker, whereas other compilers just know this.
        # Other compilers may need something slightly different.  At
        # this time, there's no way to determine this information from
        # the configuration data stored in the Python installation, so
        # we use this hack.
        compiler = os.path.basename(sysconfig.get_config_var("CC"))
        if sys.platform[:6] == "darwin":
            # MacOSX's linker doesn't understand the -R flag at all
            return "-L" + dir
        elif sys.platform[:7] == "freebsd":
            return "-Wl,-rpath=" + dir
        elif sys.platform[:5] == "hp-ux":
            if self._is_gcc(compiler):
                return ["-Wl,+s", "-L" + dir]
            return ["+s", "-L" + dir]
        elif sys.platform[:7] == "irix646" or sys.platform[:6] == "osf1V5":
            return ["-rpath", dir]
        elif self._is_gcc(compiler):
            return "-Wl,-R" + dir
        else:
            return "-R" + dir

def library_option(self, lib):
        return "-l" + lib

def find_library_file(self, dirs, lib, debug=0):
        shared_f = self.library_filename(lib, lib_type='shared')
        dylib_f = self.library_filename(lib, lib_type='dylib')
        xcode_stub_f = self.library_filename(lib, lib_type='xcode_stub')
        static_f = self.library_filename(lib, lib_type='static')

if sys.platform == 'darwin':
            # On OSX users can specify an alternate SDK using
            # '-isysroot', calculate the SDK root if it is specified
            # (and use it further on)
            #
            # Note that, as of Xcode 7, Apple SDKs may contain textual stub
            # libraries with .tbd extensions rather than the normal .dylib
            # shared libraries installed in /.  The Apple compiler tool
            # chain handles this transparently but it can cause problems
            # for programs that are being built with an SDK and searching
            # for specific libraries.  Callers of find_library_file need to
            # keep in mind that the base filename of the returned SDK library
            # file might have a different extension from that of the library
            # file installed on the running system, for example:
            #   /Applications/Xcode.app/Contents/Developer/Platforms/
            #       MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/
            #       usr/lib/libedit.tbd
            # vs
            #   /usr/lib/libedit.dylib
            cflags = sysconfig.get_config_var('CFLAGS')
            m = re.search(r'-isysroot\s+(\S+)', cflags)
            if m is None:
                sysroot = '/'
            else:
                sysroot = m.group(1)

for dir in dirs:
            shared = os.path.join(dir, shared_f)
            dylib = os.path.join(dir, dylib_f)
            static = os.path.join(dir, static_f)
            xcode_stub = os.path.join(dir, xcode_stub_f)

if sys.platform == 'darwin' and (
                dir.startswith('/System/') or (
                dir.startswith('/usr/') and not dir.startswith('/usr/local/'))):

shared = os.path.join(sysroot, dir[1:], shared_f)
                dylib = os.path.join(sysroot, dir[1:], dylib_f)
                static = os.path.join(sysroot, dir[1:], static_f)
                xcode_stub = os.path.join(sysroot, dir[1:], xcode_stub_f)

# We're second-guessing the linker here, with not much hard
            # data to go on: GCC seems to prefer the shared library, so I'm
            # assuming that *all* Unix C compilers do.  And of course I'm
            # ignoring even GCC's "-static" option.  So sue me.
            if os.path.exists(dylib):
                return dylib
            elif os.path.exists(xcode_stub):
                return xcode_stub
            elif os.path.exists(shared):
                return shared
            elif os.path.exists(static):
                return static

# Oops, didn't find it in *any* of 'dirs'
        return None
unixccompiler.py.distutils-rpath000064400000032555151702014350013146 0ustar00"""distutils.unixccompiler

__revision__ = "$Id$"

import os, sys, re
from types import StringType, NoneType

if sys.platform == 'darwin':
    import _osx_support

class UnixCCompiler(CCompiler):

compiler_type = 'unix'

if sys.platform[:6] == "darwin":
        executables['ranlib'] = ["ranlib"]

def create_static_lib(self, objects, output_libname,
                          output_dir=None, debug=0, target_lang=None):
        objects, output_dir = self._fix_object_args(objects, output_dir)

output_filename = \
            self.library_filename(output_libname, output_dir=output_dir)

def link(self, target_desc, objects,
             output_filename, output_dir=None, libraries=None,
             library_dirs=None, runtime_library_dirs=None,
             export_symbols=None, debug=0, extra_preargs=None,
             extra_postargs=None, build_temp=None, target_lang=None):
        objects, output_dir = self._fix_object_args(objects, output_dir)
        libraries, library_dirs, runtime_library_dirs = \
            self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)

linker[i] = self.compiler_cxx[i]

if sys.platform == 'darwin':
                    linker = _osx_support.compiler_fixup(linker, ld_args)

self.spawn(linker + ld_args)
            except DistutilsExecError, msg:
                raise LinkError, msg
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

# -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

def library_dir_option(self, dir):
        return "-L" + dir

def _is_gcc(self, compiler_name):
        return "gcc" in compiler_name or "g++" in compiler_name

def library_option(self, lib):
        return "-l" + lib

if sys.platform == 'darwin' and (
                dir.startswith('/System/') or (
                dir.startswith('/usr/') and not dir.startswith('/usr/local/'))):

# Oops, didn't find it in *any* of 'dirs'
        return None
util.py000064400000043474151702014350006105 0ustar00"""distutils.util

Miscellaneous utility functions -- anything that doesn't fit into
one of the other *util.py modules.
"""

__revision__ = "$Id$"

import sys, os, string, re
from distutils.errors import DistutilsPlatformError
from distutils.dep_util import newer
from distutils.spawn import spawn
from distutils import log
from distutils.errors import DistutilsByteCompileError

def get_platform ():
    """Return a string that identifies the current platform.  This is used
    mainly to distinguish platform-specific build directories and
    platform-specific built distributions.  Typically includes the OS name
    and version and the architecture (as supplied by 'os.uname()'),
    although the exact information included depends on the OS; eg. for IRIX
    the architecture isn't particularly important (IRIX only runs on SGI
    hardware), but for Linux the kernel version isn't particularly
    important.

Examples of returned values:
       linux-i586
       linux-alpha (?)
       solaris-2.6-sun4u
       irix-5.3
       irix64-6.2

For other non-POSIX platforms, currently just returns 'sys.platform'.
    """
    if os.name == 'nt':
        # sniff sys.version for architecture.
        prefix = " bit ("
        i = string.find(sys.version, prefix)
        if i == -1:
            return sys.platform
        j = string.find(sys.version, ")", i)
        look = sys.version[i+len(prefix):j].lower()
        if look=='amd64':
            return 'win-amd64'
        if look=='itanium':
            return 'win-ia64'
        return sys.platform

# Set for cross builds explicitly
    if "_PYTHON_HOST_PLATFORM" in os.environ:
        return os.environ["_PYTHON_HOST_PLATFORM"]

if os.name != "posix" or not hasattr(os, 'uname'):
        # XXX what about the architecture? NT is Intel or Alpha,
        # Mac OS is M68k or PPC, etc.
        return sys.platform

# Try to distinguish various flavours of Unix

(osname, host, release, version, machine) = os.uname()

# Convert the OS name to lowercase, remove '/' characters
    # (to accommodate BSD/OS), and translate spaces (for "Power Macintosh")
    osname = string.lower(osname)
    osname = string.replace(osname, '/', '')
    machine = string.replace(machine, ' ', '_')
    machine = string.replace(machine, '/', '-')

if osname[:5] == "linux":
        # At least on Linux/Intel, 'machine' is the processor --
        # i386, etc.
        # XXX what about Alpha, SPARC, etc?
        return  "%s-%s" % (osname, machine)
    elif osname[:5] == "sunos":
        if release[0] >= "5":           # SunOS 5 == Solaris 2
            osname = "solaris"
            release = "%d.%s" % (int(release[0]) - 3, release[2:])
            # We can't use "platform.architecture()[0]" because a
            # bootstrap problem. We use a dict to get an error
            # if some suspicious happens.
            bitness = {2147483647:"32bit", 9223372036854775807:"64bit"}
            machine += ".%s" % bitness[sys.maxint]
        # fall through to standard osname-release-machine representation
    elif osname[:4] == "irix":              # could be "irix64"!
        return "%s-%s" % (osname, release)
    elif osname[:3] == "aix":
        return "%s-%s.%s" % (osname, version, release)
    elif osname[:6] == "cygwin":
        osname = "cygwin"
        rel_re = re.compile (r'[\d.]+')
        m = rel_re.match(release)
        if m:
            release = m.group()
    elif osname[:6] == "darwin":
        import _osx_support, distutils.sysconfig
        osname, release, machine = _osx_support.get_platform_osx(
                                        distutils.sysconfig.get_config_vars(),
                                        osname, release, machine)

return "%s-%s-%s" % (osname, release, machine)

# get_platform ()

def convert_path (pathname):
    """Return 'pathname' as a name that will work on the native filesystem,
    i.e. split it on '/' and put it back together again using the current
    directory separator.  Needed because filenames in the setup script are
    always supplied in Unix style, and have to be converted to the local
    convention before we can actually use them in the filesystem.  Raises
    ValueError on non-Unix-ish systems if 'pathname' either starts or
    ends with a slash.
    """
    if os.sep == '/':
        return pathname
    if not pathname:
        return pathname
    if pathname[0] == '/':
        raise ValueError, "path '%s' cannot be absolute" % pathname
    if pathname[-1] == '/':
        raise ValueError, "path '%s' cannot end with '/'" % pathname

paths = string.split(pathname, '/')
    while '.' in paths:
        paths.remove('.')
    if not paths:
        return os.curdir
    return os.path.join(*paths)

# convert_path ()

def change_root (new_root, pathname):
    """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
    relative, this is equivalent to "os.path.join(new_root,pathname)".
    Otherwise, it requires making 'pathname' relative and then joining the
    two, which is tricky on DOS/Windows and Mac OS.
    """
    if os.name == 'posix':
        if not os.path.isabs(pathname):
            return os.path.join(new_root, pathname)
        else:
            return os.path.join(new_root, pathname[1:])

elif os.name == 'nt':
        (drive, path) = os.path.splitdrive(pathname)
        if path[0] == '\\':
            path = path[1:]
        return os.path.join(new_root, path)

elif os.name == 'os2':
        (drive, path) = os.path.splitdrive(pathname)
        if path[0] == os.sep:
            path = path[1:]
        return os.path.join(new_root, path)

else:
        raise DistutilsPlatformError, \
              "nothing known about platform '%s'" % os.name

_environ_checked = 0
def check_environ ():
    """Ensure that 'os.environ' has all the environment variables we
    guarantee that users can use in config files, command-line options,
    etc.  Currently this includes:
      HOME - user's home directory (Unix only)
      PLAT - description of the current platform, including hardware
             and OS (see 'get_platform()')
    """
    global _environ_checked
    if _environ_checked:
        return

if os.name == 'posix' and 'HOME' not in os.environ:
        try:
            import pwd
            os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
        except (ImportError, KeyError):
            # bpo-10496: if the current user identifier doesn't exist in the
            # password database, do nothing
            pass

if 'PLAT' not in os.environ:
        os.environ['PLAT'] = get_platform()

_environ_checked = 1

def subst_vars (s, local_vars):
    """Perform shell/Perl-style variable substitution on 'string'.  Every
    occurrence of '$' followed by a name is considered a variable, and
    variable is substituted by the value found in the 'local_vars'
    dictionary, or in 'os.environ' if it's not in 'local_vars'.
    'os.environ' is first checked/augmented to guarantee that it contains
    certain values: see 'check_environ()'.  Raise ValueError for any
    variables not found in either 'local_vars' or 'os.environ'.
    """
    check_environ()
    def _subst (match, local_vars=local_vars):
        var_name = match.group(1)
        if var_name in local_vars:
            return str(local_vars[var_name])
        else:
            return os.environ[var_name]

try:
        return re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
    except KeyError, var:
        raise ValueError, "invalid variable '$%s'" % var

# subst_vars ()

def grok_environment_error (exc, prefix="error: "):
    # Function kept for backward compatibility.
    # Used to try clever things with EnvironmentErrors,
    # but nowadays str(exception) produces good messages.
    return prefix + str(exc)

# Needed by 'split_quoted()'
_wordchars_re = _squote_re = _dquote_re = None
def _init_regex():
    global _wordchars_re, _squote_re, _dquote_re
    _wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
    _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
    _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')

def split_quoted (s):
    """Split a string up according to Unix shell-like rules for quotes and
    backslashes.  In short: words are delimited by spaces, as long as those
    spaces are not escaped by a backslash, or inside a quoted string.
    Single and double quotes are equivalent, and the quote characters can
    be backslash-escaped.  The backslash is stripped from any two-character
    escape sequence, leaving only the escaped character.  The quote
    characters are stripped from any quoted string.  Returns a list of
    words.
    """

# This is a nice algorithm for splitting up a single string, since it
    # doesn't require character-by-character examination.  It was a little
    # bit of a brain-bender to get it working right, though...
    if _wordchars_re is None: _init_regex()

s = string.strip(s)
    words = []
    pos = 0

while s:
        m = _wordchars_re.match(s, pos)
        end = m.end()
        if end == len(s):
            words.append(s[:end])
            break

if s[end] in string.whitespace: # unescaped, unquoted whitespace: now
            words.append(s[:end])       # we definitely have a word delimiter
            s = string.lstrip(s[end:])
            pos = 0

elif s[end] == '\\':            # preserve whatever is being escaped;
                                        # will become part of the current word
            s = s[:end] + s[end+1:]
            pos = end+1

else:
            if s[end] == "'":           # slurp singly-quoted string
                m = _squote_re.match(s, end)
            elif s[end] == '"':         # slurp doubly-quoted string
                m = _dquote_re.match(s, end)
            else:
                raise RuntimeError, \
                      "this can't happen (bad char '%c')" % s[end]

if m is None:
                raise ValueError, \
                      "bad string (mismatched %s quotes?)" % s[end]

(beg, end) = m.span()
            s = s[:beg] + s[beg+1:end-1] + s[end:]
            pos = m.end() - 2

if pos >= len(s):
            words.append(s)
            break

return words

# split_quoted ()

def execute (func, args, msg=None, verbose=0, dry_run=0):
    """Perform some action that affects the outside world (eg.  by
    writing to the filesystem).  Such actions are special because they
    are disabled by the 'dry_run' flag.  This method takes care of all
    that bureaucracy for you; all you have to do is supply the
    function to call and an argument tuple for it (to embody the
    "external action" being performed), and an optional message to
    print.
    """
    if msg is None:
        msg = "%s%r" % (func.__name__, args)
        if msg[-2:] == ',)':        # correct for singleton tuple
            msg = msg[0:-2] + ')'

log.info(msg)
    if not dry_run:
        func(*args)

def strtobool (val):
    """Convert a string representation of truth to true (1) or false (0).

True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
    'val' is anything else.
    """
    val = string.lower(val)
    if val in ('y', 'yes', 't', 'true', 'on', '1'):
        return 1
    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
        return 0
    else:
        raise ValueError, "invalid truth value %r" % (val,)

def byte_compile (py_files,
                  optimize=0, force=0,
                  prefix=None, base_dir=None,
                  verbose=1, dry_run=0,
                  direct=None):
    """Byte-compile a collection of Python source files to either .pyc
    or .pyo files in the same directory.  'py_files' is a list of files
    to compile; any files that don't end in ".py" are silently skipped.
    'optimize' must be one of the following:
      0 - don't optimize (generate .pyc)
      1 - normal optimization (like "python -O")
      2 - extra optimization (like "python -OO")
    If 'force' is true, all files are recompiled regardless of
    timestamps.

If 'dry_run' is true, doesn't actually do anything that would
    affect the filesystem.

# First, if the caller didn't force us into direct or indirect mode,
    # figure out which mode we should be in.  We take a conservative
    # approach: choose direct mode *only* if the current interpreter is
    # in debug mode and optimize is 0.  If we're not in debug mode (-O
    # or -OO), we don't know which level of optimization this
    # interpreter is running with, so we can't do direct
    # byte-compilation and be certain that it's the right thing.  Thus,
    # always compile indirectly if the current interpreter is in either
    # optimize mode, or if either optimization level was requested by
    # the caller.
    if direct is None:
        direct = (__debug__ and optimize == 0)

# "Indirect" byte-compilation: write a temporary script and then
    # run it with the appropriate flags.
    if not direct:
        try:
            from tempfile import mkstemp
            (script_fd, script_name) = mkstemp(".py")
        except ImportError:
            from tempfile import mktemp
            (script_fd, script_name) = None, mktemp(".py")
        log.info("writing byte-compilation script '%s'", script_name)
        if not dry_run:
            if script_fd is not None:
                script = os.fdopen(script_fd, "w")
            else:
                script = open(script_name, "w")

script.write("""\
from distutils.util import byte_compile
files = [
""")

# XXX would be nice to write absolute filenames, just for
            # safety's sake (script should be more robust in the face of
            # chdir'ing before running it).  But this requires abspath'ing
            # 'prefix' as well, and that breaks the hack in build_lib's
            # 'byte_compile()' method that carefully tacks on a trailing
            # slash (os.sep really) to make sure the prefix here is "just
            # right".  This whole prefix business is rather delicate -- the
            # problem is that it's really a directory, but I'm treating it
            # as a dumb string, so trailing slashes and so forth matter.

#py_files = map(os.path.abspath, py_files)
            #if prefix:
            #    prefix = os.path.abspath(prefix)

script.write(string.join(map(repr, py_files), ",\n") + "]\n")
            script.write("""
byte_compile(files, optimize=%r, force=%r,
             prefix=%r, base_dir=%r,
             verbose=%r, dry_run=0,
             direct=1)
""" % (optimize, force, prefix, base_dir, verbose))

script.close()

cmd = [sys.executable, script_name]
        if optimize == 1:
            cmd.insert(1, "-O")
        elif optimize == 2:
            cmd.insert(1, "-OO")
        spawn(cmd, dry_run=dry_run)
        execute(os.remove, (script_name,), "removing %s" % script_name,
                dry_run=dry_run)

# "Direct" byte-compilation: use the py_compile module to compile
    # right here, right now.  Note that the script generated in indirect
    # mode simply calls 'byte_compile()' in direct mode, a weird sort of
    # cross-process recursion.  Hey, it works!
    else:
        from py_compile import compile

for file in py_files:
            if file[-3:] != ".py":
                # This lets us be lazy and not filter filenames in
                # the "install_lib" command.
                continue

# Terminology from the py_compile module:
            #   cfile - byte-compiled file
            #   dfile - purported source filename (same as 'file' by default)
            cfile = file + (__debug__ and "c" or "o")
            dfile = file
            if prefix:
                if file[:len(prefix)] != prefix:
                    raise ValueError, \
                          ("invalid prefix: filename %r doesn't start with %r"
                           % (file, prefix))
                dfile = dfile[len(prefix):]
            if base_dir:
                dfile = os.path.join(base_dir, dfile)

cfile_base = os.path.basename(cfile)
            if direct:
                if force or newer(file, cfile):
                    log.info("byte-compiling %s to %s", file, cfile_base)
                    if not dry_run:
                        compile(file, cfile, dfile)
                else:
                    log.debug("skipping byte-compilation of %s to %s",
                              file, cfile_base)

# byte_compile ()

def rfc822_escape (header):
    """Return a version of the string escaped for inclusion in an
    RFC-822 header, by ensuring there are 8 spaces space after each newline.
    """
    lines = string.split(header, '\n')
    header = string.join(lines, '\n' + 8*' ')
    return header
util.pyo000064400000034062151702014350006255 0ustar00�
{fc@s1dZdZddlZddlZddlZddlZddlmZddlm	Z	ddl
mZddlm
Z
ddlmZd	�Zd
�Zd�Zdad
�Zd�Zdd�Zdaaad�Zd�Zdddd�Zd�Zdddddddd�Zd�ZdS(sudistutils.util

Examples of returned values:
       linux-i586
       linux-alpha (?)
       solaris-2.6-sun4u
       irix-5.3
       irix64-6.2

If 'dry_run' is true, doesn't actually do anything that would
    affect the filesystem.

cCs,tj|d�}tj|dd�}|S(s�Return a version of the string escaped for inclusion in an
    RFC-822 header, by ensuring there are 8 spaces space after each newline.
    s
iRs        (RRBRF(theadertlines((s&/usr/lib64/python2.7/distutils/util.pyt
rfc822_escape�s( t__doc__t__revision__RRRR)tdistutils.errorsRtdistutils.dep_utilRtdistutils.spawnRR=RRR>RIRORRRXR`RbRjRdReRfRgRtR|R�R�R�(((s&/usr/lib64/python2.7/distutils/util.pyt<module>s00	^						?	�version.py000064400000026251151702014350006607 0ustar00#
# distutils/version.py
#
# Implements multiple version numbering conventions for the
# Python Module Distribution Utilities.
#
# $Id$
#

"""Provides classes to represent module version numbers (one class for
each style of version numbering).  There are currently two such classes
implemented: StrictVersion and LooseVersion.

import string, re
from types import StringType

class Version:
    """Abstract base class for version numbering classes.  Just provides
    constructor (__init__) and reproducer (__repr__), because those
    seem to be the same for all version numbering classes.
    """

def __init__ (self, vstring=None):
        if vstring:
            self.parse(vstring)

def __repr__ (self):
        return "%s ('%s')" % (self.__class__.__name__, str(self))

# Interface for version-number classes -- must be implemented
# by the following classes (the concrete ones -- Version should
# be treated as an abstract class).
#    __init__ (string) - create and take same action as 'parse'
#                        (string parameter is optional)
#    parse (string)    - convert a string representation to whatever
#                        internal representation is appropriate for
#                        this style of version numbering
#    __str__ (self)    - convert back to a string; should be very similar
#                        (if not identical to) the string supplied to parse
#    __repr__ (self)   - generate Python code to recreate
#                        the instance
#    __cmp__ (self, other) - compare two version numbers ('other' may
#                        be an unparsed version string, or another
#                        instance of your version class)

class StrictVersion (Version):

"""Version numbering for anal retentives and software idealists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of two or three
    dot-separated numeric components, with an optional "pre-release" tag
    on the end.  The pre-release tag consists of the letter 'a' or 'b'
    followed by a number.  If the numeric components of two version
    numbers are equal, then one with a pre-release tag will always
    be deemed earlier (lesser) than one without.

The following are valid version numbers (shown in the order that
    would be obtained by sorting according to the supplied cmp function):

0.4       0.4.0  (these two are equivalent)
        0.4.1
        0.5a1
        0.5b3
        0.5
        0.9.6
        1.0
        1.0.4a3
        1.0.4b1
        1.0.4

The following are examples of invalid version numbers:

1
        2.7.2.2
        1.3.a4
        1.3pl1
        1.3c4

The rationale for this version numbering system will be explained
    in the distutils documentation.
    """

version_re = re.compile(r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$',
                            re.VERBOSE)

def parse (self, vstring):
        match = self.version_re.match(vstring)
        if not match:
            raise ValueError, "invalid version number '%s'" % vstring

(major, minor, patch, prerelease, prerelease_num) = \
            match.group(1, 2, 4, 5, 6)

if patch:
            self.version = tuple(map(string.atoi, [major, minor, patch]))
        else:
            self.version = tuple(map(string.atoi, [major, minor]) + [0])

if prerelease:
            self.prerelease = (prerelease[0], string.atoi(prerelease_num))
        else:
            self.prerelease = None

def __str__ (self):

if self.version[2] == 0:
            vstring = string.join(map(str, self.version[0:2]), '.')
        else:
            vstring = string.join(map(str, self.version), '.')

if self.prerelease:
            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])

return vstring

def __cmp__ (self, other):
        if isinstance(other, StringType):
            other = StrictVersion(other)

compare = cmp(self.version, other.version)
        if (compare == 0):              # have to compare prerelease

# case 1: neither has prerelease; they're equal
            # case 2: self has prerelease, other doesn't; other is greater
            # case 3: self doesn't have prerelease, other does: self is greater
            # case 4: both have prerelease: must compare them!

if (not self.prerelease and not other.prerelease):
                return 0
            elif (self.prerelease and not other.prerelease):
                return -1
            elif (not self.prerelease and other.prerelease):
                return 1
            elif (self.prerelease and other.prerelease):
                return cmp(self.prerelease, other.prerelease)

else:                           # numeric versions don't match --
            return compare              # prerelease stuff doesn't matter

# end class StrictVersion

# The rules according to Greg Stein:
# 1) a version number has 1 or more numbers separated by a period or by
#    sequences of letters. If only periods, then these are compared
#    left-to-right to determine an ordering.
# 2) sequences of letters are part of the tuple for comparison and are
#    compared lexicographically
# 3) recognize the numeric components may have leading zeroes
#
# The LooseVersion class below implements these rules: a version number
# string is split up into a tuple of integer and string components, and
# comparison is a simple tuple comparison.  This means that version
# numbers behave in a predictable and obvious way, but a way that might
# not necessarily be how people *want* version numbers to behave.  There
# wouldn't be a problem if people could stick to purely numeric version
# numbers: just split on period and compare the numbers as tuples.
# However, people insist on putting letters into their version numbers;
# the most common purpose seems to be:
#   - indicating a "pre-release" version
#     ('alpha', 'beta', 'a', 'b', 'pre', 'p')
#   - indicating a post-release patch ('p', 'pl', 'patch')
# but of course this can't cover all version number schemes, and there's
# no way to know what a programmer means without asking him.
#
# The problem is what to do with letters (and other non-numeric
# characters) in a version number.  The current implementation does the
# obvious and predictable thing: keep them as strings and compare
# lexically within a tuple comparison.  This has the desired effect if
# an appended letter sequence implies something "post-release":
# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
#
# However, if letters in a version number imply a pre-release version,
# the "obvious" thing isn't correct.  Eg. you would expect that
# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
# implemented here, this just isn't so.
#
# Two possible solutions come to mind.  The first is to tie the
# comparison algorithm to a particular set of semantic rules, as has
# been done in the StrictVersion class above.  This works great as long
# as everyone can go along with bondage and discipline.  Hopefully a
# (large) subset of Python module programmers will agree that the
# particular flavour of bondage and discipline provided by StrictVersion
# provides enough benefit to be worth using, and will submit their
# version numbering scheme to its domination.  The free-thinking
# anarchists in the lot will never give in, though, and something needs
# to be done to accommodate them.
#
# Perhaps a "moderately strict" version class could be implemented that
# lets almost anything slide (syntactically), and makes some heuristic
# assumptions about non-digits in version number strings.  This could
# sink into special-case-hell, though; if I was as talented and
# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
# just as happy dealing with things like "2g6" and "1.13++".  I don't
# think I'm smart enough to do it right though.
#
# In any case, I've coded the test suite for this module (see
# ../test/test_version.py) specifically to fail on things like comparing
# "1.2a2" and "1.2".  That's not because the *code* is doing anything
# wrong, it's because the simple, obvious design doesn't match my
# complicated, hairy expectations for real-world version numbers.  It
# would be a snap to fix the test suite to say, "Yep, LooseVersion does
# the Right Thing" (ie. the code matches the conception).  But I'd rather
# have a conception that matches common notions about version numbers.

class LooseVersion (Version):

"""Version numbering for anarchists and software realists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of a series of numbers,
    separated by either periods or strings of letters.  When comparing
    version numbers, the numeric components will be compared
    numerically, and the alphabetic components lexically.  The following
    are all valid version numbers, in no particular order:

component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)

def __init__ (self, vstring=None):
        if vstring:
            self.parse(vstring)

def parse (self, vstring):
        # I've given up on thinking I can reconstruct the version string
        # from the parsed tuple -- so I just store the string here for
        # use by __str__
        self.vstring = vstring
        components = filter(lambda x: x and x != '.',
                            self.component_re.split(vstring))
        for i in range(len(components)):
            try:
                components[i] = int(components[i])
            except ValueError:
                pass

self.version = components

def __str__ (self):
        return self.vstring

def __repr__ (self):
        return "LooseVersion ('%s')" % str(self)

def __cmp__ (self, other):
        if isinstance(other, StringType):
            other = LooseVersion(other)

return cmp(self.version, other.version)

# end class LooseVersion
version.pyo000064400000016050151702014350006762 0ustar00�
{fc@sqdZddlZddlZddlmZdd
d��YZdefd��YZdefd	��YZdS(s�Provides classes to represent module version numbers (one class for
each style of version numbering).  There are currently two such classes
implemented: StrictVersion and LooseVersion.

The following are valid version numbers (shown in the order that
    would be obtained by sorting according to the supplied cmp function):

0.4       0.4.0  (these two are equivalent)
        0.4.1
        0.5a1
        0.5b3
        0.5
        0.9.6
        1.0
        1.0.4a3
        1.0.4b1
        1.0.4

The following are examples of invalid version numbers:

1
        2.7.2.2
        1.3.a4
        1.3pl1
        1.3c4

In fact, there is no such thing as an invalid version number under
    this scheme; the rules for comparison are simple and predictable,
    but may not always give the results you want (for some definition
    of "want").
    s(\d+ | [a-z]+ | \.)cCs|r|j|�ndS(N(R(RR((s)/usr/lib64/python2.7/distutils/version.pyRscCs}||_td�|jj|��}xFtt|��D]2}yt||�||<Wq:tk
rkq:Xq:W||_dS(NcSs|o|dkS(NR((tx((s)/usr/lib64/python2.7/distutils/version.pyt<lambda>t(	Rtfiltertcomponent_retsplittrangetlentintRR(RRt
componentsti((s)/usr/lib64/python2.7/distutils/version.pyRs		
cCs|jS(N(R(R((s)/usr/lib64/python2.7/distutils/version.pyRscCsdt|�S(NsLooseVersion ('%s')(R(R((s)/usr/lib64/python2.7/distutils/version.pyR	 scCs1t|t�rt|�}nt|j|j�S(N(RRR'R R(RR!((s)/usr/lib64/python2.7/distutils/version.pyR#$sN(
RR
RR$R%R&R,RRRRR	R#(((s)/usr/lib64/python2.7/distutils/version.pyR'�s			((RRR$ttypesRRR
R'(((s)/usr/lib64/python2.7/distutils/version.pyt<module>s
�versionpredicate.py000064400000011747151702014350010474 0ustar00"""Module for parsing and testing package version predicate strings.
"""
import re
import distutils.version
import operator

re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)")
# (package) (rest)

re_paren = re.compile(r"^\s*$(.*)$\s*$") # (list) inside of parentheses
re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
# (comp) (version)

def splitUp(pred):
    """Parse a single version comparison.

Return (comparison string, StrictVersion)
    """
    res = re_splitComparison.match(pred)
    if not res:
        raise ValueError("bad package restriction syntax: %r" % pred)
    comp, verStr = res.groups()
    return (comp, distutils.version.StrictVersion(verStr))

compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq,
           ">": operator.gt, ">=": operator.ge, "!=": operator.ne}

class VersionPredicate:
    """Parse and test package version predicates.