proj/gentoo: Initial commit

This commit represents a new era for Gentoo:
Storing the gentoo-x86 tree in Git, as converted from CVS.

This commit is the start of the NEW history.
Any historical data is intended to be grafted onto this point.

Creation process:
1. Take final CVS checkout snapshot
2. Remove ALL ChangeLog* files
3. Transform all Manifests to thin
4. Remove empty Manifests
5. Convert all stale $Header$/$Id$ CVS keywords to non-expanded Git $Id$
5.1. Do not touch files with -kb/-ko keyword flags.

Signed-off-by: Robin H. Johnson <robbat2@gentoo.org>
X-Thanks: Alec Warner <antarus@gentoo.org> - did the GSoC 2006 migration tests
X-Thanks: Robin H. Johnson <robbat2@gentoo.org> - infra guy, herding this project
X-Thanks: Nguyen Thai Ngoc Duy <pclouds@gentoo.org> - Former Gentoo developer, wrote Git features for the migration
X-Thanks: Brian Harring <ferringb@gentoo.org> - wrote much python to improve cvs2svn
X-Thanks: Rich Freeman <rich0@gentoo.org> - validation scripts
X-Thanks: Patrick Lauer <patrick@gentoo.org> - Gentoo dev, running new 2014 work in migration
X-Thanks: Michał Górny <mgorny@gentoo.org> - scripts, QA, nagging
X-Thanks: All of other Gentoo developers - many ideas and lots of paint on the bikeshed

15 files changed, 3551 insertions, 0 deletions

diff --git a/dev-python/paste/Manifest b/dev-python/paste/Manifest
new file mode 100644
index 000000000000..2b6d4408db17
--- /dev/null
+++ b/dev-python/paste/Manifest
@@ -0,0 +1,2 @@
+DIST Paste-1.7.5.1.tar.gz 523304 SHA256 11645842ba8ec986ae8cfbe4c6cacff5c35f0f4527abf4f5581ae8b4ad49c0b6 SHA512 058a86dec41f132c22b14f3bc882d9c02c04bb0cc9ea5fc5371911698c3d7a89859742a4b806ad388c7fe37289b816db16c50bce21f56c8371293c4d91b5ccb6 WHIRLPOOL 5928a6f20c136a77576b653df34337f1eb110845b8d53d7637eeb6c792fe7f10fe622adefec382378aef16c1abee91c37e90e5fe17dbaa07046681a393f6c5c8
+DIST Paste-2.0.2.tar.gz 627842 SHA256 adac3ac893a2dac6b8ffd49901377dd6819e05be3436b374d698641071daba99 SHA512 32eddeab1bab9d0b1a30848d89613b40ed02a77912f7ef5a86880e1c1a860c5637cd45114bd58cc5ac84410a569ede67e6ebd7afd2007c588433d54d6940f529 WHIRLPOOL 08c997079e632b92e592211d942298235228ec22b997d549f608552f139a941cdd47a5c2da859867c279cab0ad7f388823f1af163ed7ea8aeaaa7558407e3750
diff --git a/dev-python/paste/files/paste-1.7.5.1-email-mime.patch b/dev-python/paste/files/paste-1.7.5.1-email-mime.patch
new file mode 100644
index 000000000000..4c06997b0809
--- /dev/null
+++ b/dev-python/paste/files/paste-1.7.5.1-email-mime.patch
@@ -0,0 +1,19 @@
+--- a/paste/exceptions/reporter.py
++++ b/paste/exceptions/reporter.py
+@@ -1,8 +1,14 @@
+ # (c) 2005 Ian Bicking and contributors; written for Paste (http://pythonpaste.org)
+ # Licensed under the MIT license: http://www.opensource.org/licenses/mit-license.php
+ 
+-from email.MIMEText import MIMEText
+-from email.MIMEMultipart import MIMEMultipart
++try:
++    from email.MIMEText import MIMEText
++except:
++    from email.mime.text import MIMEText
++try:
++    from email.MIMEMultipart import MIMEMultipart
++except:
++    from email.mime.multipart import MIMEMultipart
+ import smtplib
+ import time
+ try:
diff --git a/dev-python/paste/files/paste-1.7.5.1-fix-tests-for-pypy.patch b/dev-python/paste/files/paste-1.7.5.1-fix-tests-for-pypy.patch
new file mode 100644
index 000000000000..b5e9430c3bb9
--- /dev/null
+++ b/dev-python/paste/files/paste-1.7.5.1-fix-tests-for-pypy.patch
@@ -0,0 +1,24 @@
+Ignore the exception detail for two exceptions that are slightly
+different on pypy.
+
+diff -r 7f90a96378ed tests/test_template.txt
+--- a/tests/test_template.txt	Mon Mar 05 21:14:08 2012 +0100
++++ b/tests/test_template.txt	Wed May 16 23:29:46 2012 +0200
+@@ -6,7 +6,7 @@
+     'Hi Ian'
+     >>> Template('Hi {{repr(name)}}').substitute(name='Ian')
+     "Hi 'Ian'"
+-    >>> Template('Hi {{name+1}}').substitute(name='Ian')
++    >>> Template('Hi {{name+1}}').substitute(name='Ian') #doctest: +IGNORE_EXCEPTION_DETAIL
+     Traceback (most recent call last):
+         ...
+     TypeError: cannot concatenate 'str' and 'int' objects at line 1 column 6
+@@ -125,7 +125,7 @@
+     >>> sub('{{default x=1}}{{x}}')
+     '1'
+     >>> # The normal case:
+-    >>> sub('{{x}}')
++    >>> sub('{{x}}') #doctest: +IGNORE_EXCEPTION_DETAIL
+     Traceback (most recent call last):
+         ...
+     NameError: name 'x' is not defined at line 1 column 3
diff --git a/dev-python/paste/files/paste-1.7.5.1-hmac.patch b/dev-python/paste/files/paste-1.7.5.1-hmac.patch
new file mode 100644
index 000000000000..c86d0f977cfe
--- /dev/null
+++ b/dev-python/paste/files/paste-1.7.5.1-hmac.patch
@@ -0,0 +1,11 @@
+--- a/paste/auth/cookie.py
++++ b/paste/auth/cookie.py
+@@ -52,7 +52,7 @@
+ 
+ def make_time(value):
+     return time.strftime("%Y%m%d%H%M", time.gmtime(value))
+-_signature_size = len(hmac.new('x', 'x', sha1).digest())
++_signature_size = len(hmac.new(b'x', b'x', sha1).digest())
+ _header_size = _signature_size + len(make_time(time.time()))
+ 
+ # @@: Should this be using urllib.quote?
diff --git a/dev-python/paste/files/paste-1.7.5.1-python27-lambda.patch b/dev-python/paste/files/paste-1.7.5.1-python27-lambda.patch
new file mode 100644
index 000000000000..91dcad137153
--- /dev/null
+++ b/dev-python/paste/files/paste-1.7.5.1-python27-lambda.patch
@@ -0,0 +1,12 @@
+diff -r 30425672adf7 paste/auth/cookie.py
+--- a/paste/auth/cookie.py	Wed Jun 23 17:15:45 2010 -0500
++++ b/paste/auth/cookie.py	Mon Aug 02 20:06:43 2010 -0700
+@@ -62,7 +62,7 @@
+ _decode = [(v, k) for (k, v) in _encode]
+ _decode.reverse()
+ def encode(s, sublist = _encode):
+-    return reduce((lambda a, (b, c): a.replace(b, c)), sublist, str(s))
++    return reduce((lambda a, b: a.replace(b[0], b[1])), sublist, str(s))
+ decode = lambda s: encode(s, _decode)
+ 
+ class CookieTooLarge(RuntimeError):
diff --git a/dev-python/paste/files/paste-1.7.5.1-rfc822.patch b/dev-python/paste/files/paste-1.7.5.1-rfc822.patch
new file mode 100644
index 000000000000..e0950fcaabef
--- /dev/null
+++ b/dev-python/paste/files/paste-1.7.5.1-rfc822.patch
@@ -0,0 +1,14 @@
+--- a/paste/httpheaders.py
++++ b/paste/httpheaders.py
+@@ -137,7 +137,10 @@
+ import mimetypes
+ import urllib2
+ import re
+-from rfc822 import formatdate, parsedate_tz, mktime_tz
++try:
++    from rfc822 import formatdate, parsedate_tz, mktime_tz
++except ImportError:
++    from email.utils import formatdate, parsedate_tz, mktime_tz
+ from time import time as now
+ from httpexceptions import HTTPBadRequest
+ 
diff --git a/dev-python/paste/files/paste-1.7.5.1-types.patch b/dev-python/paste/files/paste-1.7.5.1-types.patch
new file mode 100644
index 000000000000..87ea53c39648
--- /dev/null
+++ b/dev-python/paste/files/paste-1.7.5.1-types.patch
@@ -0,0 +1,57 @@
+--- a/paste/lint.py
++++ b/paste/lint.py
+@@ -111,7 +111,6 @@
+ 
+ import re
+ import sys
+-from types import DictType, StringType, TupleType, ListType
+ import warnings
+ 
+ header_re = re.compile(r'^[a-zA-Z][a-zA-Z0-9\-_]*$')
+@@ -282,7 +281,7 @@
+             "Iterator garbage collected without being closed")
+ 
+ def check_environ(environ):
+-    assert type(environ) is DictType, (
++    assert isinstance(environ,dict), (
+         "Environment is not of the right type: %r (environment: %r)"
+         % (type(environ), environ))
+     
+@@ -309,11 +308,11 @@
+         if '.' in key:
+             # Extension, we don't care about its type
+             continue
+-        assert type(environ[key]) is StringType, (
++        assert isinstance(environ[key], str), (
+             "Environmental variable %s is not a string: %r (value: %r)"
+             % (key, type(environ[key]), environ[key]))
+         
+-    assert type(environ['wsgi.version']) is TupleType, (
++    assert isinstance(environ['wsgi.version'], tuple), (
+         "wsgi.version should be a tuple (%r)" % environ['wsgi.version'])
+     assert environ['wsgi.url_scheme'] in ('http', 'https'), (
+         "wsgi.url_scheme unknown: %r" % environ['wsgi.url_scheme'])
+@@ -359,7 +358,7 @@
+             % (wsgi_errors, attr))
+ 
+ def check_status(status):
+-    assert type(status) is StringType, (
++    assert isinstance(status, str), (
+         "Status must be a string (not %r)" % status)
+     # Implicitly check that we can turn it into an integer:
+     status_code = status.split(None, 1)[0]
+@@ -374,12 +373,12 @@
+             % status, WSGIWarning)
+ 
+ def check_headers(headers):
+-    assert type(headers) is ListType, (
++    assert isinstance(headers,list), (
+         "Headers (%r) must be of type list: %r"
+         % (headers, type(headers)))
+     header_names = {}
+     for item in headers:
+-        assert type(item) is TupleType, (
++        assert isinstance(item, tuple), (
+             "Individual headers (%r) must be of type tuple: %r"
+             % (item, type(item)))
+         assert len(item) == 2
diff --git a/dev-python/paste/files/paste-1.7.5.1-unbundle-stdlib.patch b/dev-python/paste/files/paste-1.7.5.1-unbundle-stdlib.patch
new file mode 100644
index 000000000000..b389df2482c7
--- /dev/null
+++ b/dev-python/paste/files/paste-1.7.5.1-unbundle-stdlib.patch
@@ -0,0 +1,1211 @@
+--- a/paste/debug/fsdiff.py
++++ b/paste/debug/fsdiff.py
+@@ -12,7 +12,10 @@
+ import os
+ from fnmatch import fnmatch
+ from datetime import datetime
+-from paste.util.UserDict24 import IterableUserDict
++try:
++    from UserDict import IterableUserDict
++except ImportError:
++    from paste.util.UserDict24 import IterableUserDict
+ import operator
+ import re
+ 
+--- a/paste/debug/doctest_webapp.py
++++ b/paste/debug/doctest_webapp.py
+@@ -8,10 +8,7 @@
+ These are functions for use when doctest-testing a document.
+ """
+ 
+-try:
+-    import subprocess
+-except ImportError:
+-    from paste.util import subprocess24 as subprocess
++import subprocess
+ import doctest
+ import os
+ import sys
+--- a/paste/debug/wdg_validate.py
++++ b/paste/debug/wdg_validate.py
+@@ -6,10 +6,7 @@
+ """
+ 
+ from cStringIO import StringIO
+-try:
+-    import subprocess
+-except ImportError:
+-    from paste.util import subprocess24 as subprocess
++import subprocess
+ from paste.response import header_value
+ import re
+ import cgi
+--- a/paste/fixture.py
++++ b/paste/fixture.py
+@@ -26,10 +26,7 @@
+ except ImportError:
+     from StringIO import StringIO
+ import re
+-try:
+-    import subprocess
+-except ImportError:
+-    from paste.util import subprocess24 as subprocess
++import subprocess
+ 
+ from paste import wsgilib
+ from paste import lint
+--- a/paste/util/subprocess24.py
++++ /dev/null
+@@ -1,1152 +0,0 @@
+-# subprocess - Subprocesses with accessible I/O streams
+-#
+-# For more information about this module, see PEP 324.
+-#
+-# This module should remain compatible with Python 2.2, see PEP 291.
+-#
+-# Copyright (c) 2003-2005 by Peter Astrand <astrand@lysator.liu.se>
+-#
+-# Licensed to PSF under a Contributor Agreement.
+-# See http://www.python.org/2.4/license for licensing details.
+-
+-r"""subprocess - Subprocesses with accessible I/O streams
+-
+-This module allows you to spawn processes, connect to their
+-input/output/error pipes, and obtain their return codes.  This module
+-intends to replace several other, older modules and functions, like:
+-
+-os.system
+-os.spawn*
+-os.popen*
+-popen2.*
+-commands.*
+-
+-Information about how the subprocess module can be used to replace these
+-modules and functions can be found below.
+-
+-
+-
+-Using the subprocess module
+-===========================
+-This module defines one class called Popen:
+-
+-class Popen(args, bufsize=0, executable=None,
+-            stdin=None, stdout=None, stderr=None,
+-            preexec_fn=None, close_fds=False, shell=False,
+-            cwd=None, env=None, universal_newlines=False,
+-            startupinfo=None, creationflags=0):
+-
+-
+-Arguments are:
+-
+-args should be a string, or a sequence of program arguments.  The
+-program to execute is normally the first item in the args sequence or
+-string, but can be explicitly set by using the executable argument.
+-
+-On UNIX, with shell=False (default): In this case, the Popen class
+-uses os.execvp() to execute the child program.  args should normally
+-be a sequence.  A string will be treated as a sequence with the string
+-as the only item (the program to execute).
+-
+-On UNIX, with shell=True: If args is a string, it specifies the
+-command string to execute through the shell.  If args is a sequence,
+-the first item specifies the command string, and any additional items
+-will be treated as additional shell arguments.
+-
+-On Windows: the Popen class uses CreateProcess() to execute the child
+-program, which operates on strings.  If args is a sequence, it will be
+-converted to a string using the list2cmdline method.  Please note that
+-not all MS Windows applications interpret the command line the same
+-way: The list2cmdline is designed for applications using the same
+-rules as the MS C runtime.
+-
+-bufsize, if given, has the same meaning as the corresponding argument
+-to the built-in open() function: 0 means unbuffered, 1 means line
+-buffered, any other positive value means use a buffer of
+-(approximately) that size.  A negative bufsize means to use the system
+-default, which usually means fully buffered.  The default value for
+-bufsize is 0 (unbuffered).
+-
+-stdin, stdout and stderr specify the executed programs' standard
+-input, standard output and standard error file handles, respectively.
+-Valid values are PIPE, an existing file descriptor (a positive
+-integer), an existing file object, and None.  PIPE indicates that a
+-new pipe to the child should be created.  With None, no redirection
+-will occur; the child's file handles will be inherited from the
+-parent.  Additionally, stderr can be STDOUT, which indicates that the
+-stderr data from the applications should be captured into the same
+-file handle as for stdout.
+-
+-If preexec_fn is set to a callable object, this object will be called
+-in the child process just before the child is executed.
+-
+-If close_fds is true, all file descriptors except 0, 1 and 2 will be
+-closed before the child process is executed.
+-
+-if shell is true, the specified command will be executed through the
+-shell.
+-
+-If cwd is not None, the current directory will be changed to cwd
+-before the child is executed.
+-
+-If env is not None, it defines the environment variables for the new
+-process.
+-
+-If universal_newlines is true, the file objects stdout and stderr are
+-opened as a text files, but lines may be terminated by any of '\n',
+-the Unix end-of-line convention, '\r', the Macintosh convention or
+-'\r\n', the Windows convention.  All of these external representations
+-are seen as '\n' by the Python program.  Note: This feature is only
+-available if Python is built with universal newline support (the
+-default).  Also, the newlines attribute of the file objects stdout,
+-stdin and stderr are not updated by the communicate() method.
+-
+-The startupinfo and creationflags, if given, will be passed to the
+-underlying CreateProcess() function.  They can specify things such as
+-appearance of the main window and priority for the new process.
+-(Windows only)
+-
+-
+-This module also defines two shortcut functions:
+-
+-call(*args, **kwargs):
+-    Run command with arguments.  Wait for command to complete, then
+-    return the returncode attribute. The arguments are the same as for
+-    the Popen constructor.  Example:
+-
+-    retcode = call(["ls", "-l"])
+-
+-
+-Exceptions
+-----------
+-Exceptions raised in the child process, before the new program has
+-started to execute, will be re-raised in the parent.  Additionally,
+-the exception object will have one extra attribute called
+-'child_traceback', which is a string containing traceback information
+-from the childs point of view.
+-
+-The most common exception raised is OSError.  This occurs, for
+-example, when trying to execute a non-existent file.  Applications
+-should prepare for OSErrors.
+-
+-A ValueError will be raised if Popen is called with invalid arguments.
+-
+-
+-Security
+---------
+-Unlike some other popen functions, this implementation will never call
+-/bin/sh implicitly.  This means that all characters, including shell
+-metacharacters, can safely be passed to child processes.
+-
+-
+-Popen objects
+-=============
+-Instances of the Popen class have the following methods:
+-
+-poll()
+-    Check if child process has terminated.  Returns returncode
+-    attribute.
+-
+-wait()
+-    Wait for child process to terminate.  Returns returncode attribute.
+-
+-communicate(input=None)
+-    Interact with process: Send data to stdin.  Read data from stdout
+-    and stderr, until end-of-file is reached.  Wait for process to
+-    terminate.  The optional stdin argument should be a string to be
+-    sent to the child process, or None, if no data should be sent to
+-    the child.
+-
+-    communicate() returns a tuple (stdout, stderr).
+-
+-    Note: The data read is buffered in memory, so do not use this
+-    method if the data size is large or unlimited.
+-
+-The following attributes are also available:
+-
+-stdin
+-    If the stdin argument is PIPE, this attribute is a file object
+-    that provides input to the child process.  Otherwise, it is None.
+-
+-stdout
+-    If the stdout argument is PIPE, this attribute is a file object
+-    that provides output from the child process.  Otherwise, it is
+-    None.
+-
+-stderr
+-    If the stderr argument is PIPE, this attribute is file object that
+-    provides error output from the child process.  Otherwise, it is
+-    None.
+-
+-pid
+-    The process ID of the child process.
+-
+-returncode
+-    The child return code.  A None value indicates that the process
+-    hasn't terminated yet.  A negative value -N indicates that the
+-    child was terminated by signal N (UNIX only).
+-
+-
+-Replacing older functions with the subprocess module
+-====================================================
+-In this section, "a ==> b" means that b can be used as a replacement
+-for a.
+-
+-Note: All functions in this section fail (more or less) silently if
+-the executed program cannot be found; this module raises an OSError
+-exception.
+-
+-In the following examples, we assume that the subprocess module is
+-imported with "from subprocess import *".
+-
+-
+-Replacing /bin/sh shell backquote
+----------------------------------
+-output=`mycmd myarg`
+-==>
+-output = Popen(["mycmd", "myarg"], stdout=PIPE).communicate()[0]
+-
+-
+-Replacing shell pipe line
+--------------------------
+-output=`dmesg | grep hda`
+-==>
+-p1 = Popen(["dmesg"], stdout=PIPE)
+-p2 = Popen(["grep", "hda"], stdin=p1.stdout, stdout=PIPE)
+-output = p2.communicate()[0]
+-
+-
+-Replacing os.system()
+----------------------
+-sts = os.system("mycmd" + " myarg")
+-==>
+-p = Popen("mycmd" + " myarg", shell=True)
+-sts = os.waitpid(p.pid, 0)
+-
+-Note:
+-
+-* Calling the program through the shell is usually not required.
+-
+-* It's easier to look at the returncode attribute than the
+-  exitstatus.
+-
+-A more real-world example would look like this:
+-
+-try:
+-    retcode = call("mycmd" + " myarg", shell=True)
+-    if retcode < 0:
+-        print >>sys.stderr, "Child was terminated by signal", -retcode
+-    else:
+-        print >>sys.stderr, "Child returned", retcode
+-except OSError, e:
+-    print >>sys.stderr, "Execution failed:", e
+-
+-
+-Replacing os.spawn*
+--------------------
+-P_NOWAIT example:
+-
+-pid = os.spawnlp(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg")
+-==>
+-pid = Popen(["/bin/mycmd", "myarg"]).pid
+-
+-
+-P_WAIT example:
+-
+-retcode = os.spawnlp(os.P_WAIT, "/bin/mycmd", "mycmd", "myarg")
+-==>
+-retcode = call(["/bin/mycmd", "myarg"])
+-
+-
+-Vector example:
+-
+-os.spawnvp(os.P_NOWAIT, path, args)
+-==>
+-Popen([path] + args[1:])
+-
+-
+-Environment example:
+-
+-os.spawnlpe(os.P_NOWAIT, "/bin/mycmd", "mycmd", "myarg", env)
+-==>
+-Popen(["/bin/mycmd", "myarg"], env={"PATH": "/usr/bin"})
+-
+-
+-Replacing os.popen*
+--------------------
+-pipe = os.popen(cmd, mode='r', bufsize)
+-==>
+-pipe = Popen(cmd, shell=True, bufsize=bufsize, stdout=PIPE).stdout
+-
+-pipe = os.popen(cmd, mode='w', bufsize)
+-==>
+-pipe = Popen(cmd, shell=True, bufsize=bufsize, stdin=PIPE).stdin
+-
+-
+-(child_stdin, child_stdout) = os.popen2(cmd, mode, bufsize)
+-==>
+-p = Popen(cmd, shell=True, bufsize=bufsize,
+-          stdin=PIPE, stdout=PIPE, close_fds=True)
+-(child_stdin, child_stdout) = (p.stdin, p.stdout)
+-
+-
+-(child_stdin,
+- child_stdout,
+- child_stderr) = os.popen3(cmd, mode, bufsize)
+-==>
+-p = Popen(cmd, shell=True, bufsize=bufsize,
+-          stdin=PIPE, stdout=PIPE, stderr=PIPE, close_fds=True)
+-(child_stdin,
+- child_stdout,
+- child_stderr) = (p.stdin, p.stdout, p.stderr)
+-
+-
+-(child_stdin, child_stdout_and_stderr) = os.popen4(cmd, mode, bufsize)
+-==>
+-p = Popen(cmd, shell=True, bufsize=bufsize,
+-          stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
+-(child_stdin, child_stdout_and_stderr) = (p.stdin, p.stdout)
+-
+-
+-Replacing popen2.*
+-------------------
+-Note: If the cmd argument to popen2 functions is a string, the command
+-is executed through /bin/sh.  If it is a list, the command is directly
+-executed.
+-
+-(child_stdout, child_stdin) = popen2.popen2("somestring", bufsize, mode)
+-==>
+-p = Popen(["somestring"], shell=True, bufsize=bufsize
+-          stdin=PIPE, stdout=PIPE, close_fds=True)
+-(child_stdout, child_stdin) = (p.stdout, p.stdin)
+-
+-
+-(child_stdout, child_stdin) = popen2.popen2(["mycmd", "myarg"], bufsize, mode)
+-==>
+-p = Popen(["mycmd", "myarg"], bufsize=bufsize,
+-          stdin=PIPE, stdout=PIPE, close_fds=True)
+-(child_stdout, child_stdin) = (p.stdout, p.stdin)
+-
+-The popen2.Popen3 and popen3.Popen4 basically works as subprocess.Popen,
+-except that:
+-
+-* subprocess.Popen raises an exception if the execution fails
+-* the capturestderr argument is replaced with the stderr argument.
+-* stdin=PIPE and stdout=PIPE must be specified.
+-* popen2 closes all filedescriptors by default, but you have to specify
+-  close_fds=True with subprocess.Popen.
+-
+-
+-"""
+-
+-import sys
+-mswindows = (sys.platform == "win32")
+-
+-import os
+-import types
+-import traceback
+-
+-if mswindows:
+-    import threading
+-    import msvcrt
+-    ## @@: Changed in Paste
+-    ## Since this module is only used on pre-python-2.4 systems, they probably
+-    ## don't have _subprocess installed, but hopefully have the win32 stuff
+-    ## installed.
+-    if 1: # <-- change this to use pywin32 instead of the _subprocess driver
+-        import pywintypes
+-        from win32api import GetStdHandle, STD_INPUT_HANDLE, \
+-                             STD_OUTPUT_HANDLE, STD_ERROR_HANDLE
+-        from win32api import GetCurrentProcess, DuplicateHandle, \
+-                             GetModuleFileName, GetVersion
+-        from win32con import DUPLICATE_SAME_ACCESS, SW_HIDE
+-        from win32pipe import CreatePipe
+-        from win32process import CreateProcess, STARTUPINFO, \
+-                                 GetExitCodeProcess, STARTF_USESTDHANDLES, \
+-                                 STARTF_USESHOWWINDOW, CREATE_NEW_CONSOLE
+-        from win32event import WaitForSingleObject, INFINITE, WAIT_OBJECT_0
+-    else:
+-        from _subprocess import *
+-        class STARTUPINFO:
+-            dwFlags = 0
+-            hStdInput = None
+-            hStdOutput = None
+-            hStdError = None
+-        class pywintypes:
+-            error = IOError
+-else:
+-    import select
+-    import errno
+-    import fcntl
+-    import pickle
+-
+-__all__ = ["Popen", "PIPE", "STDOUT", "call"]
+-
+-try:
+-    MAXFD = os.sysconf("SC_OPEN_MAX")
+-except:
+-    MAXFD = 256
+-
+-# True/False does not exist on 2.2.0
+-try:
+-    False
+-except NameError:
+-    False = 0
+-    True = 1
+-
+-_active = []
+-
+-def _cleanup():
+-    for inst in _active[:]:
+-        inst.poll()
+-
+-PIPE = -1
+-STDOUT = -2
+-
+-
+-def call(*args, **kwargs):
+-    """Run command with arguments.  Wait for command to complete, then
+-    return the returncode attribute.
+-
+-    The arguments are the same as for the Popen constructor.  Example:
+-
+-    retcode = call(["ls", "-l"])
+-    """
+-    return Popen(*args, **kwargs).wait()
+-
+-
+-def list2cmdline(seq):
+-    """
+-    Translate a sequence of arguments into a command line
+-    string, using the same rules as the MS C runtime:
+-
+-    1) Arguments are delimited by white space, which is either a
+-       space or a tab.
+-
+-    2) A string surrounded by double quotation marks is
+-       interpreted as a single argument, regardless of white space
+-       contained within.  A quoted string can be embedded in an
+-       argument.
+-
+-    3) A double quotation mark preceded by a backslash is
+-       interpreted as a literal double quotation mark.
+-
+-    4) Backslashes are interpreted literally, unless they
+-       immediately precede a double quotation mark.
+-
+-    5) If backslashes immediately precede a double quotation mark,
+-       every pair of backslashes is interpreted as a literal
+-       backslash.  If the number of backslashes is odd, the last
+-       backslash escapes the next double quotation mark as
+-       described in rule 3.
+-    """
+-
+-    # See
+-    # http://msdn.microsoft.com/library/en-us/vccelng/htm/progs_12.asp
+-    result = []
+-    needquote = False
+-    for arg in seq:
+-        bs_buf = []
+-
+-        # Add a space to separate this argument from the others
+-        if result:
+-            result.append(' ')
+-
+-        needquote = (" " in arg) or ("\t" in arg)
+-        if needquote:
+-            result.append('"')
+-
+-        for c in arg:
+-            if c == '\\':
+-                # Don't know if we need to double yet.
+-                bs_buf.append(c)
+-            elif c == '"':
+-                # Double backspaces.
+-                result.append('\\' * len(bs_buf)*2)
+-                bs_buf = []
+-                result.append('\\"')
+-            else:
+-                # Normal char
+-                if bs_buf:
+-                    result.extend(bs_buf)
+-                    bs_buf = []
+-                result.append(c)
+-
+-        # Add remaining backspaces, if any.
+-        if bs_buf:
+-            result.extend(bs_buf)
+-
+-        if needquote:
+-            result.extend(bs_buf)
+-            result.append('"')
+-
+-    return ''.join(result)
+-
+-
+-class Popen(object):
+-    def __init__(self, args, bufsize=0, executable=None,
+-                 stdin=None, stdout=None, stderr=None,
+-                 preexec_fn=None, close_fds=False, shell=False,
+-                 cwd=None, env=None, universal_newlines=False,
+-                 startupinfo=None, creationflags=0):
+-        """Create new Popen instance."""
+-        _cleanup()
+-
+-        if not isinstance(bufsize, (int, long)):
+-            raise TypeError("bufsize must be an integer")
+-
+-        if mswindows:
+-            if preexec_fn is not None:
+-                raise ValueError("preexec_fn is not supported on Windows "
+-                                 "platforms")
+-            if close_fds:
+-                raise ValueError("close_fds is not supported on Windows "
+-                                 "platforms")
+-        else:
+-            # POSIX
+-            if startupinfo is not None:
+-                raise ValueError("startupinfo is only supported on Windows "
+-                                 "platforms")
+-            if creationflags != 0:
+-                raise ValueError("creationflags is only supported on Windows "
+-                                 "platforms")
+-
+-        self.stdin = None
+-        self.stdout = None
+-        self.stderr = None
+-        self.pid = None
+-        self.returncode = None
+-        self.universal_newlines = universal_newlines
+-
+-        # Input and output objects. The general principle is like
+-        # this:
+-        #
+-        # Parent                   Child
+-        # ------                   -----
+-        # p2cwrite   ---stdin--->  p2cread
+-        # c2pread    <--stdout---  c2pwrite
+-        # errread    <--stderr---  errwrite
+-        #
+-        # On POSIX, the child objects are file descriptors.  On
+-        # Windows, these are Windows file handles.  The parent objects
+-        # are file descriptors on both platforms.  The parent objects
+-        # are None when not using PIPEs. The child objects are None
+-        # when not redirecting.
+-
+-        (p2cread, p2cwrite,
+-         c2pread, c2pwrite,
+-         errread, errwrite) = self._get_handles(stdin, stdout, stderr)
+-
+-        self._execute_child(args, executable, preexec_fn, close_fds,
+-                            cwd, env, universal_newlines,
+-                            startupinfo, creationflags, shell,
+-                            p2cread, p2cwrite,
+-                            c2pread, c2pwrite,
+-                            errread, errwrite)
+-
+-        if p2cwrite:
+-            self.stdin = os.fdopen(p2cwrite, 'wb', bufsize)
+-        if c2pread:
+-            if universal_newlines:
+-                self.stdout = os.fdopen(c2pread, 'rU', bufsize)
+-            else:
+-                self.stdout = os.fdopen(c2pread, 'rb', bufsize)
+-        if errread:
+-            if universal_newlines:
+-                self.stderr = os.fdopen(errread, 'rU', bufsize)
+-            else:
+-                self.stderr = os.fdopen(errread, 'rb', bufsize)
+-
+-        _active.append(self)
+-
+-
+-    def _translate_newlines(self, data):
+-        data = data.replace("\r\n", "\n")
+-        data = data.replace("\r", "\n")
+-        return data
+-
+-
+-    if mswindows:
+-        #
+-        # Windows methods
+-        #
+-        def _get_handles(self, stdin, stdout, stderr):
+-            """Construct and return tupel with IO objects:
+-            p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite
+-            """
+-            if stdin == None and stdout == None and stderr == None:
+-                return (None, None, None, None, None, None)
+-
+-            p2cread, p2cwrite = None, None
+-            c2pread, c2pwrite = None, None
+-            errread, errwrite = None, None
+-
+-            if stdin == None:
+-                p2cread = GetStdHandle(STD_INPUT_HANDLE)
+-            elif stdin == PIPE:
+-                p2cread, p2cwrite = CreatePipe(None, 0)
+-                # Detach and turn into fd
+-                p2cwrite = p2cwrite.Detach()
+-                p2cwrite = msvcrt.open_osfhandle(p2cwrite, 0)
+-            elif type(stdin) == types.IntType:
+-                p2cread = msvcrt.get_osfhandle(stdin)
+-            else:
+-                # Assuming file-like object
+-                p2cread = msvcrt.get_osfhandle(stdin.fileno())
+-            p2cread = self._make_inheritable(p2cread)
+-
+-            if stdout == None:
+-                c2pwrite = GetStdHandle(STD_OUTPUT_HANDLE)
+-            elif stdout == PIPE:
+-                c2pread, c2pwrite = CreatePipe(None, 0)
+-                # Detach and turn into fd
+-                c2pread = c2pread.Detach()
+-                c2pread = msvcrt.open_osfhandle(c2pread, 0)
+-            elif type(stdout) == types.IntType:
+-                c2pwrite = msvcrt.get_osfhandle(stdout)
+-            else:
+-                # Assuming file-like object
+-                c2pwrite = msvcrt.get_osfhandle(stdout.fileno())
+-            c2pwrite = self._make_inheritable(c2pwrite)
+-
+-            if stderr == None:
+-                errwrite = GetStdHandle(STD_ERROR_HANDLE)
+-            elif stderr == PIPE:
+-                errread, errwrite = CreatePipe(None, 0)
+-                # Detach and turn into fd
+-                errread = errread.Detach()
+-                errread = msvcrt.open_osfhandle(errread, 0)
+-            elif stderr == STDOUT:
+-                errwrite = c2pwrite
+-            elif type(stderr) == types.IntType:
+-                errwrite = msvcrt.get_osfhandle(stderr)
+-            else:
+-                # Assuming file-like object
+-                errwrite = msvcrt.get_osfhandle(stderr.fileno())
+-            errwrite = self._make_inheritable(errwrite)
+-
+-            return (p2cread, p2cwrite,
+-                    c2pread, c2pwrite,
+-                    errread, errwrite)
+-
+-