Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 1 of 2.

1 files changed, 573 insertions, 573 deletions

diff --git a/contrib/python/ipython/py3/IPython/utils/_process_win32_controller.py b/contrib/python/ipython/py3/IPython/utils/_process_win32_controller.py
index c2e2329c45..e2889800de 100644
--- a/contrib/python/ipython/py3/IPython/utils/_process_win32_controller.py
+++ b/contrib/python/ipython/py3/IPython/utils/_process_win32_controller.py
@@ -1,573 +1,573 @@
-"""Windows-specific implementation of process utilities with direct WinAPI.
-
-This file is meant to be used by process.py
-"""
-
-#-----------------------------------------------------------------------------
-#  Copyright (C) 2010-2011  The IPython Development Team
-#
-#  Distributed under the terms of the BSD License.  The full license is in
-#  the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-
-# stdlib
-import os, sys, threading
-import ctypes, msvcrt
-
-# Win32 API types needed for the API calls
-from ctypes import POINTER
-from ctypes.wintypes import HANDLE, HLOCAL, LPVOID, WORD, DWORD, BOOL, \
-        ULONG, LPCWSTR
-LPDWORD = POINTER(DWORD)
-LPHANDLE = POINTER(HANDLE)
-ULONG_PTR = POINTER(ULONG)
-class SECURITY_ATTRIBUTES(ctypes.Structure):
-    _fields_ = [("nLength", DWORD),
-                ("lpSecurityDescriptor", LPVOID),
-                ("bInheritHandle", BOOL)]
-LPSECURITY_ATTRIBUTES = POINTER(SECURITY_ATTRIBUTES)
-class STARTUPINFO(ctypes.Structure):
-    _fields_ = [("cb", DWORD),
-                ("lpReserved", LPCWSTR),
-                ("lpDesktop", LPCWSTR),
-                ("lpTitle", LPCWSTR),
-                ("dwX", DWORD),
-                ("dwY", DWORD),
-                ("dwXSize", DWORD),
-                ("dwYSize", DWORD),
-                ("dwXCountChars", DWORD),
-                ("dwYCountChars", DWORD),
-                ("dwFillAttribute", DWORD),
-                ("dwFlags", DWORD),
-                ("wShowWindow", WORD),
-                ("cbReserved2", WORD),
-                ("lpReserved2", LPVOID),
-                ("hStdInput", HANDLE),
-                ("hStdOutput", HANDLE),
-                ("hStdError", HANDLE)]
-LPSTARTUPINFO = POINTER(STARTUPINFO)
-class PROCESS_INFORMATION(ctypes.Structure):
-    _fields_ = [("hProcess", HANDLE),
-                ("hThread", HANDLE),
-                ("dwProcessId", DWORD),
-                ("dwThreadId", DWORD)]
-LPPROCESS_INFORMATION = POINTER(PROCESS_INFORMATION)
-
-# Win32 API constants needed
-ERROR_HANDLE_EOF = 38
-ERROR_BROKEN_PIPE = 109
-ERROR_NO_DATA = 232
-HANDLE_FLAG_INHERIT = 0x0001
-STARTF_USESTDHANDLES = 0x0100
-CREATE_SUSPENDED = 0x0004
-CREATE_NEW_CONSOLE = 0x0010
-CREATE_NO_WINDOW = 0x08000000
-STILL_ACTIVE = 259
-WAIT_TIMEOUT = 0x0102
-WAIT_FAILED = 0xFFFFFFFF
-INFINITE = 0xFFFFFFFF
-DUPLICATE_SAME_ACCESS = 0x00000002
-ENABLE_ECHO_INPUT = 0x0004
-ENABLE_LINE_INPUT = 0x0002
-ENABLE_PROCESSED_INPUT = 0x0001
-
-# Win32 API functions needed
-GetLastError = ctypes.windll.kernel32.GetLastError
-GetLastError.argtypes = []
-GetLastError.restype = DWORD
-
-CreateFile = ctypes.windll.kernel32.CreateFileW
-CreateFile.argtypes = [LPCWSTR, DWORD, DWORD, LPVOID, DWORD, DWORD, HANDLE]
-CreateFile.restype = HANDLE
-
-CreatePipe = ctypes.windll.kernel32.CreatePipe
-CreatePipe.argtypes = [POINTER(HANDLE), POINTER(HANDLE),
-        LPSECURITY_ATTRIBUTES, DWORD]
-CreatePipe.restype = BOOL
-
-CreateProcess = ctypes.windll.kernel32.CreateProcessW
-CreateProcess.argtypes = [LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES,
-        LPSECURITY_ATTRIBUTES, BOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO,
-        LPPROCESS_INFORMATION]
-CreateProcess.restype = BOOL
-
-GetExitCodeProcess = ctypes.windll.kernel32.GetExitCodeProcess
-GetExitCodeProcess.argtypes = [HANDLE, LPDWORD]
-GetExitCodeProcess.restype = BOOL
-
-GetCurrentProcess = ctypes.windll.kernel32.GetCurrentProcess
-GetCurrentProcess.argtypes = []
-GetCurrentProcess.restype = HANDLE
-
-ResumeThread = ctypes.windll.kernel32.ResumeThread
-ResumeThread.argtypes = [HANDLE]
-ResumeThread.restype = DWORD
-
-ReadFile = ctypes.windll.kernel32.ReadFile
-ReadFile.argtypes = [HANDLE, LPVOID, DWORD, LPDWORD, LPVOID]
-ReadFile.restype = BOOL
-
-WriteFile = ctypes.windll.kernel32.WriteFile
-WriteFile.argtypes = [HANDLE, LPVOID, DWORD, LPDWORD, LPVOID]
-WriteFile.restype = BOOL
-
-GetConsoleMode = ctypes.windll.kernel32.GetConsoleMode
-GetConsoleMode.argtypes = [HANDLE, LPDWORD]
-GetConsoleMode.restype = BOOL
-
-SetConsoleMode = ctypes.windll.kernel32.SetConsoleMode
-SetConsoleMode.argtypes = [HANDLE, DWORD]
-SetConsoleMode.restype = BOOL
-
-FlushConsoleInputBuffer = ctypes.windll.kernel32.FlushConsoleInputBuffer
-FlushConsoleInputBuffer.argtypes = [HANDLE]
-FlushConsoleInputBuffer.restype = BOOL
-
-WaitForSingleObject = ctypes.windll.kernel32.WaitForSingleObject
-WaitForSingleObject.argtypes = [HANDLE, DWORD]
-WaitForSingleObject.restype = DWORD
-
-DuplicateHandle = ctypes.windll.kernel32.DuplicateHandle
-DuplicateHandle.argtypes = [HANDLE, HANDLE, HANDLE, LPHANDLE,
-        DWORD, BOOL, DWORD]
-DuplicateHandle.restype = BOOL
-
-SetHandleInformation = ctypes.windll.kernel32.SetHandleInformation
-SetHandleInformation.argtypes = [HANDLE, DWORD, DWORD]
-SetHandleInformation.restype = BOOL
-
-CloseHandle = ctypes.windll.kernel32.CloseHandle
-CloseHandle.argtypes = [HANDLE]
-CloseHandle.restype = BOOL
-
-CommandLineToArgvW = ctypes.windll.shell32.CommandLineToArgvW
-CommandLineToArgvW.argtypes = [LPCWSTR, POINTER(ctypes.c_int)]
-CommandLineToArgvW.restype = POINTER(LPCWSTR)
-
-LocalFree = ctypes.windll.kernel32.LocalFree
-LocalFree.argtypes = [HLOCAL]
-LocalFree.restype = HLOCAL
-
-class AvoidUNCPath(object):
-    """A context manager to protect command execution from UNC paths.
-
-    In the Win32 API, commands can't be invoked with the cwd being a UNC path.
-    This context manager temporarily changes directory to the 'C:' drive on
-    entering, and restores the original working directory on exit.
-
-    The context manager returns the starting working directory *if* it made a
-    change and None otherwise, so that users can apply the necessary adjustment
-    to their system calls in the event of a change.
-
-    Examples
-    --------
-    ::
-        cmd = 'dir'
-        with AvoidUNCPath() as path:
-            if path is not None:
-                cmd = '"pushd %s &&"%s' % (path, cmd)
-            os.system(cmd)
-    """
-    def __enter__(self):
-        self.path = os.getcwd()
-        self.is_unc_path = self.path.startswith(r"\\")
-        if self.is_unc_path:
-            # change to c drive (as cmd.exe cannot handle UNC addresses)
-            os.chdir("C:")
-            return self.path
-        else:
-            # We return None to signal that there was no change in the working
-            # directory
-            return None
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        if self.is_unc_path:
-            os.chdir(self.path)
-
-
-class Win32ShellCommandController(object):
-    """Runs a shell command in a 'with' context.
-
-    This implementation is Win32-specific.
-
-    Example:
-        # Runs the command interactively with default console stdin/stdout
-        with ShellCommandController('python -i') as scc:
-            scc.run()
-
-        # Runs the command using the provided functions for stdin/stdout
-        def my_stdout_func(s):
-            # print or save the string 's'
-            write_to_stdout(s)
-        def my_stdin_func():
-            # If input is available, return it as a string.
-            if input_available():
-                return get_input()
-            # If no input available, return None after a short delay to
-            # keep from blocking.
-            else:
-                time.sleep(0.01)
-                return None
-      
-        with ShellCommandController('python -i') as scc:
-            scc.run(my_stdout_func, my_stdin_func)
-    """
-
-    def __init__(self, cmd, mergeout = True):
-        """Initializes the shell command controller.
-
-        The cmd is the program to execute, and mergeout is
-        whether to blend stdout and stderr into one output
-        in stdout. Merging them together in this fashion more
-        reliably keeps stdout and stderr in the correct order
-        especially for interactive shell usage.
-        """
-        self.cmd = cmd
-        self.mergeout = mergeout
-
-    def __enter__(self):
-        cmd = self.cmd
-        mergeout = self.mergeout
-
-        self.hstdout, self.hstdin, self.hstderr = None, None, None
-        self.piProcInfo = None
-        try:
-            p_hstdout, c_hstdout, p_hstderr, \
-                    c_hstderr, p_hstdin, c_hstdin = [None]*6
-
-            # SECURITY_ATTRIBUTES with inherit handle set to True
-            saAttr = SECURITY_ATTRIBUTES()
-            saAttr.nLength = ctypes.sizeof(saAttr)
-            saAttr.bInheritHandle = True
-            saAttr.lpSecurityDescriptor = None
-
-            def create_pipe(uninherit):
-                """Creates a Windows pipe, which consists of two handles.
-
-                The 'uninherit' parameter controls which handle is not
-                inherited by the child process.
-                """
-                handles = HANDLE(), HANDLE()
-                if not CreatePipe(ctypes.byref(handles[0]),
-                            ctypes.byref(handles[1]), ctypes.byref(saAttr), 0):
-                    raise ctypes.WinError()
-                if not SetHandleInformation(handles[uninherit],
-                            HANDLE_FLAG_INHERIT, 0):
-                    raise ctypes.WinError()
-                return handles[0].value, handles[1].value
-
-            p_hstdout, c_hstdout = create_pipe(uninherit=0)
-            # 'mergeout' signals that stdout and stderr should be merged.
-            # We do that by using one pipe for both of them.
-            if mergeout:
-                c_hstderr = HANDLE()
-                if not DuplicateHandle(GetCurrentProcess(), c_hstdout,
-                                GetCurrentProcess(), ctypes.byref(c_hstderr),
-                                0, True, DUPLICATE_SAME_ACCESS):
-                    raise ctypes.WinError()
-            else:
-                p_hstderr, c_hstderr = create_pipe(uninherit=0)
-            c_hstdin,  p_hstdin  = create_pipe(uninherit=1)
-
-            # Create the process object
-            piProcInfo = PROCESS_INFORMATION()
-            siStartInfo = STARTUPINFO()
-            siStartInfo.cb = ctypes.sizeof(siStartInfo)
-            siStartInfo.hStdInput = c_hstdin
-            siStartInfo.hStdOutput = c_hstdout
-            siStartInfo.hStdError = c_hstderr
-            siStartInfo.dwFlags = STARTF_USESTDHANDLES
-            dwCreationFlags = CREATE_SUSPENDED | CREATE_NO_WINDOW # | CREATE_NEW_CONSOLE
-
-            if not CreateProcess(None,
-                    u"cmd.exe /c " + cmd,
-                    None, None, True, dwCreationFlags,
-                    None, None, ctypes.byref(siStartInfo),
-                    ctypes.byref(piProcInfo)):
-                raise ctypes.WinError()
-
-            # Close this process's versions of the child handles
-            CloseHandle(c_hstdin)
-            c_hstdin = None
-            CloseHandle(c_hstdout)
-            c_hstdout = None
-            if c_hstderr is not None:
-                CloseHandle(c_hstderr)
-                c_hstderr = None
-
-            # Transfer ownership of the parent handles to the object
-            self.hstdin = p_hstdin
-            p_hstdin = None
-            self.hstdout = p_hstdout
-            p_hstdout = None
-            if not mergeout:
-                self.hstderr = p_hstderr
-                p_hstderr = None
-            self.piProcInfo = piProcInfo
-
-        finally:
-            if p_hstdin:
-                CloseHandle(p_hstdin)
-            if c_hstdin:
-                CloseHandle(c_hstdin)
-            if p_hstdout:
-                CloseHandle(p_hstdout)
-            if c_hstdout:
-                CloseHandle(c_hstdout)
-            if p_hstderr:
-                CloseHandle(p_hstderr)
-            if c_hstderr:
-                CloseHandle(c_hstderr)
-
-        return self
-
-    def _stdin_thread(self, handle, hprocess, func, stdout_func):
-        exitCode = DWORD()
-        bytesWritten = DWORD(0)
-        while True:
-            #print("stdin thread loop start")
-            # Get the input string (may be bytes or unicode)
-            data = func()
-
-            # None signals to poll whether the process has exited
-            if data is None:
-                #print("checking for process completion")
-                if not GetExitCodeProcess(hprocess, ctypes.byref(exitCode)):
-                    raise ctypes.WinError()
-                if exitCode.value != STILL_ACTIVE:
-                    return
-                # TESTING: Does zero-sized writefile help?
-                if not WriteFile(handle, "", 0,
-                        ctypes.byref(bytesWritten), None):
-                    raise ctypes.WinError()
-                continue
-            #print("\nGot str %s\n" % repr(data), file=sys.stderr)
-
-            # Encode the string to the console encoding
-            if isinstance(data, unicode): #FIXME: Python3
-                data = data.encode('utf_8')
-
-            # What we have now must be a string of bytes
-            if not isinstance(data, str): #FIXME: Python3
-                raise RuntimeError("internal stdin function string error")
-
-            # An empty string signals EOF
-            if len(data) == 0:
-                return
-
-            # In a windows console, sometimes the input is echoed,
-            # but sometimes not. How do we determine when to do this?
-            stdout_func(data)
-            # WriteFile may not accept all the data at once.
-            # Loop until everything is processed
-            while len(data) != 0:
-                #print("Calling writefile")
-                if not WriteFile(handle, data, len(data),
-                        ctypes.byref(bytesWritten), None):
-                    # This occurs at exit
-                    if GetLastError() == ERROR_NO_DATA:
-                        return
-                    raise ctypes.WinError()
-                #print("Called writefile")
-                data = data[bytesWritten.value:]
-
-    def _stdout_thread(self, handle, func):
-        # Allocate the output buffer
-        data = ctypes.create_string_buffer(4096)
-        while True:
-            bytesRead = DWORD(0)
-            if not ReadFile(handle, data, 4096,
-                        ctypes.byref(bytesRead), None):
-                le = GetLastError()
-                if le == ERROR_BROKEN_PIPE:
-                    return
-                else:
-                    raise ctypes.WinError()
-            # FIXME: Python3
-            s = data.value[0:bytesRead.value]
-            #print("\nv: %s" % repr(s), file=sys.stderr)
-            func(s.decode('utf_8', 'replace'))
-
-    def run(self, stdout_func = None, stdin_func = None, stderr_func = None):
-        """Runs the process, using the provided functions for I/O.
-
-        The function stdin_func should return strings whenever a
-        character or characters become available.
-        The functions stdout_func and stderr_func are called whenever
-        something is printed to stdout or stderr, respectively.
-        These functions are called from different threads (but not
-        concurrently, because of the GIL).
-        """
-        if stdout_func is None and stdin_func is None and stderr_func is None:
-            return self._run_stdio()
-
-        if stderr_func is not None and self.mergeout:
-            raise RuntimeError("Shell command was initiated with "
-                    "merged stdin/stdout, but a separate stderr_func "
-                    "was provided to the run() method")
-
-        # Create a thread for each input/output handle
-        stdin_thread = None
-        threads = []
-        if stdin_func:
-            stdin_thread = threading.Thread(target=self._stdin_thread,
-                                args=(self.hstdin, self.piProcInfo.hProcess,
-                                stdin_func, stdout_func))
-        threads.append(threading.Thread(target=self._stdout_thread,
-                                    args=(self.hstdout, stdout_func)))
-        if not self.mergeout:
-            if stderr_func is None:
-                stderr_func = stdout_func
-            threads.append(threading.Thread(target=self._stdout_thread,
-                                        args=(self.hstderr, stderr_func)))
-        # Start the I/O threads and the process
-        if ResumeThread(self.piProcInfo.hThread) == 0xFFFFFFFF:
-            raise ctypes.WinError()
-        if stdin_thread is not None:
-            stdin_thread.start()
-        for thread in threads:
-            thread.start()
-        # Wait for the process to complete
-        if WaitForSingleObject(self.piProcInfo.hProcess, INFINITE) == \
-                    WAIT_FAILED:
-            raise ctypes.WinError()
-        # Wait for the I/O threads to complete
-        for thread in threads:
-            thread.join()
-
-        # Wait for the stdin thread to complete
-        if stdin_thread is not None:
-            stdin_thread.join()
-
-    def _stdin_raw_nonblock(self):
-        """Use the raw Win32 handle of sys.stdin to do non-blocking reads"""
-        # WARNING: This is experimental, and produces inconsistent results.
-        #          It's possible for the handle not to be appropriate for use
-        #          with WaitForSingleObject, among other things.
-        handle = msvcrt.get_osfhandle(sys.stdin.fileno())
-        result = WaitForSingleObject(handle, 100)
-        if result == WAIT_FAILED:
-            raise ctypes.WinError()
-        elif result == WAIT_TIMEOUT:
-            print(".", end='')
-            return None
-        else:
-            data = ctypes.create_string_buffer(256)
-            bytesRead = DWORD(0)
-            print('?', end='')
-
-            if not ReadFile(handle, data, 256,
-                        ctypes.byref(bytesRead), None):
-                raise ctypes.WinError()
-            # This ensures the non-blocking works with an actual console
-            # Not checking the error, so the processing will still work with
-            # other handle types
-            FlushConsoleInputBuffer(handle)
-
-            data = data.value
-            data = data.replace('\r\n', '\n')
-            data = data.replace('\r', '\n')
-            print(repr(data) + " ", end='')
-            return data
-
-    def _stdin_raw_block(self):
-        """Use a blocking stdin read"""
-        # The big problem with the blocking read is that it doesn't
-        # exit when it's supposed to in all contexts. An extra
-        # key-press may be required to trigger the exit.
-        try:
-            data = sys.stdin.read(1)
-            data = data.replace('\r', '\n')
-            return data
-        except WindowsError as we:
-            if we.winerror == ERROR_NO_DATA:
-                # This error occurs when the pipe is closed
-                return None
-            else:
-                # Otherwise let the error propagate
-                raise we
-
-    def _stdout_raw(self, s):
-        """Writes the string to stdout"""
-        print(s, end='', file=sys.stdout)
-        sys.stdout.flush()
-
-    def _stderr_raw(self, s):
-        """Writes the string to stdout"""
-        print(s, end='', file=sys.stderr)
-        sys.stderr.flush()
-
-    def _run_stdio(self):
-        """Runs the process using the system standard I/O.
-
-        IMPORTANT: stdin needs to be asynchronous, so the Python
-                   sys.stdin object is not used. Instead,
-                   msvcrt.kbhit/getwch are used asynchronously.
-        """
-        # Disable Line and Echo mode
-        #lpMode = DWORD()
-        #handle = msvcrt.get_osfhandle(sys.stdin.fileno())
-        #if GetConsoleMode(handle, ctypes.byref(lpMode)):
-        #    set_console_mode = True
-        #    if not SetConsoleMode(handle, lpMode.value &
-        #            ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT)):
-        #        raise ctypes.WinError()
-
-        if self.mergeout:
-            return self.run(stdout_func = self._stdout_raw,
-                    stdin_func = self._stdin_raw_block)
-        else:
-            return self.run(stdout_func = self._stdout_raw,
-                    stdin_func = self._stdin_raw_block,
-                    stderr_func = self._stderr_raw)
-
-        # Restore the previous console mode
-        #if set_console_mode:
-        #    if not SetConsoleMode(handle, lpMode.value):
-        #        raise ctypes.WinError()
-
-    def __exit__(self, exc_type, exc_value, traceback):
-        if self.hstdin:
-            CloseHandle(self.hstdin)
-            self.hstdin = None
-        if self.hstdout:
-            CloseHandle(self.hstdout)
-            self.hstdout = None
-        if self.hstderr:
-            CloseHandle(self.hstderr)
-            self.hstderr = None
-        if self.piProcInfo is not None:
-            CloseHandle(self.piProcInfo.hProcess)
-            CloseHandle(self.piProcInfo.hThread)
-            self.piProcInfo = None
-
-
-def system(cmd):
-    """Win32 version of os.system() that works with network shares.
-
-    Note that this implementation returns None, as meant for use in IPython.
-
-    Parameters
-    ----------
-    cmd : str
-      A command to be executed in the system shell.
-
-    Returns
-    -------
-    None : we explicitly do NOT return the subprocess status code, as this
-    utility is meant to be used extensively in IPython, where any return value
-    would trigger :func:`sys.displayhook` calls.
-    """
-    with AvoidUNCPath() as path:
-        if path is not None:
-            cmd = '"pushd %s &&"%s' % (path, cmd)
-        with Win32ShellCommandController(cmd) as scc:
-            scc.run()
-
-
-if __name__ == "__main__":
-    print("Test starting!")
-    #system("cmd")
-    system("python -i")
-    print("Test finished!")
+"""Windows-specific implementation of process utilities with direct WinAPI. 
+ 
+This file is meant to be used by process.py 
+""" 
+ 
+#----------------------------------------------------------------------------- 
+#  Copyright (C) 2010-2011  The IPython Development Team 
+# 
+#  Distributed under the terms of the BSD License.  The full license is in 
+#  the file COPYING, distributed as part of this software. 
+#----------------------------------------------------------------------------- 
+ 
+ 
+# stdlib 
+import os, sys, threading 
+import ctypes, msvcrt 
+ 
+# Win32 API types needed for the API calls 
+from ctypes import POINTER 
+from ctypes.wintypes import HANDLE, HLOCAL, LPVOID, WORD, DWORD, BOOL, \ 
+        ULONG, LPCWSTR 
+LPDWORD = POINTER(DWORD) 
+LPHANDLE = POINTER(HANDLE) 
+ULONG_PTR = POINTER(ULONG) 
+class SECURITY_ATTRIBUTES(ctypes.Structure): 
+    _fields_ = [("nLength", DWORD), 
+                ("lpSecurityDescriptor", LPVOID), 
+                ("bInheritHandle", BOOL)] 
+LPSECURITY_ATTRIBUTES = POINTER(SECURITY_ATTRIBUTES) 
+class STARTUPINFO(ctypes.Structure): 
+    _fields_ = [("cb", DWORD), 
+                ("lpReserved", LPCWSTR), 
+                ("lpDesktop", LPCWSTR), 
+                ("lpTitle", LPCWSTR), 
+                ("dwX", DWORD), 
+                ("dwY", DWORD), 
+                ("dwXSize", DWORD), 
+                ("dwYSize", DWORD), 
+                ("dwXCountChars", DWORD), 
+                ("dwYCountChars", DWORD), 
+                ("dwFillAttribute", DWORD), 
+                ("dwFlags", DWORD), 
+                ("wShowWindow", WORD), 
+                ("cbReserved2", WORD), 
+                ("lpReserved2", LPVOID), 
+                ("hStdInput", HANDLE), 
+                ("hStdOutput", HANDLE), 
+                ("hStdError", HANDLE)] 
+LPSTARTUPINFO = POINTER(STARTUPINFO) 
+class PROCESS_INFORMATION(ctypes.Structure): 
+    _fields_ = [("hProcess", HANDLE), 
+                ("hThread", HANDLE), 
+                ("dwProcessId", DWORD), 
+                ("dwThreadId", DWORD)] 
+LPPROCESS_INFORMATION = POINTER(PROCESS_INFORMATION) 
+ 
+# Win32 API constants needed 
+ERROR_HANDLE_EOF = 38 
+ERROR_BROKEN_PIPE = 109 
+ERROR_NO_DATA = 232 
+HANDLE_FLAG_INHERIT = 0x0001 
+STARTF_USESTDHANDLES = 0x0100 
+CREATE_SUSPENDED = 0x0004 
+CREATE_NEW_CONSOLE = 0x0010 
+CREATE_NO_WINDOW = 0x08000000 
+STILL_ACTIVE = 259 
+WAIT_TIMEOUT = 0x0102 
+WAIT_FAILED = 0xFFFFFFFF 
+INFINITE = 0xFFFFFFFF 
+DUPLICATE_SAME_ACCESS = 0x00000002 
+ENABLE_ECHO_INPUT = 0x0004 
+ENABLE_LINE_INPUT = 0x0002 
+ENABLE_PROCESSED_INPUT = 0x0001 
+ 
+# Win32 API functions needed 
+GetLastError = ctypes.windll.kernel32.GetLastError 
+GetLastError.argtypes = [] 
+GetLastError.restype = DWORD 
+ 
+CreateFile = ctypes.windll.kernel32.CreateFileW 
+CreateFile.argtypes = [LPCWSTR, DWORD, DWORD, LPVOID, DWORD, DWORD, HANDLE] 
+CreateFile.restype = HANDLE 
+ 
+CreatePipe = ctypes.windll.kernel32.CreatePipe 
+CreatePipe.argtypes = [POINTER(HANDLE), POINTER(HANDLE), 
+        LPSECURITY_ATTRIBUTES, DWORD] 
+CreatePipe.restype = BOOL 
+ 
+CreateProcess = ctypes.windll.kernel32.CreateProcessW 
+CreateProcess.argtypes = [LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES, 
+        LPSECURITY_ATTRIBUTES, BOOL, DWORD, LPVOID, LPCWSTR, LPSTARTUPINFO, 
+        LPPROCESS_INFORMATION] 
+CreateProcess.restype = BOOL 
+ 
+GetExitCodeProcess = ctypes.windll.kernel32.GetExitCodeProcess 
+GetExitCodeProcess.argtypes = [HANDLE, LPDWORD] 
+GetExitCodeProcess.restype = BOOL 
+ 
+GetCurrentProcess = ctypes.windll.kernel32.GetCurrentProcess 
+GetCurrentProcess.argtypes = [] 
+GetCurrentProcess.restype = HANDLE 
+ 
+ResumeThread = ctypes.windll.kernel32.ResumeThread 
+ResumeThread.argtypes = [HANDLE] 
+ResumeThread.restype = DWORD 
+ 
+ReadFile = ctypes.windll.kernel32.ReadFile 
+ReadFile.argtypes = [HANDLE, LPVOID, DWORD, LPDWORD, LPVOID] 
+ReadFile.restype = BOOL 
+ 
+WriteFile = ctypes.windll.kernel32.WriteFile 
+WriteFile.argtypes = [HANDLE, LPVOID, DWORD, LPDWORD, LPVOID] 
+WriteFile.restype = BOOL 
+ 
+GetConsoleMode = ctypes.windll.kernel32.GetConsoleMode 
+GetConsoleMode.argtypes = [HANDLE, LPDWORD] 
+GetConsoleMode.restype = BOOL 
+ 
+SetConsoleMode = ctypes.windll.kernel32.SetConsoleMode 
+SetConsoleMode.argtypes = [HANDLE, DWORD] 
+SetConsoleMode.restype = BOOL 
+ 
+FlushConsoleInputBuffer = ctypes.windll.kernel32.FlushConsoleInputBuffer 
+FlushConsoleInputBuffer.argtypes = [HANDLE] 
+FlushConsoleInputBuffer.restype = BOOL 
+ 
+WaitForSingleObject = ctypes.windll.kernel32.WaitForSingleObject 
+WaitForSingleObject.argtypes = [HANDLE, DWORD] 
+WaitForSingleObject.restype = DWORD 
+ 
+DuplicateHandle = ctypes.windll.kernel32.DuplicateHandle 
+DuplicateHandle.argtypes = [HANDLE, HANDLE, HANDLE, LPHANDLE, 
+        DWORD, BOOL, DWORD] 
+DuplicateHandle.restype = BOOL 
+ 
+SetHandleInformation = ctypes.windll.kernel32.SetHandleInformation 
+SetHandleInformation.argtypes = [HANDLE, DWORD, DWORD] 
+SetHandleInformation.restype = BOOL 
+ 
+CloseHandle = ctypes.windll.kernel32.CloseHandle 
+CloseHandle.argtypes = [HANDLE] 
+CloseHandle.restype = BOOL 
+ 
+CommandLineToArgvW = ctypes.windll.shell32.CommandLineToArgvW 
+CommandLineToArgvW.argtypes = [LPCWSTR, POINTER(ctypes.c_int)] 
+CommandLineToArgvW.restype = POINTER(LPCWSTR) 
+ 
+LocalFree = ctypes.windll.kernel32.LocalFree 
+LocalFree.argtypes = [HLOCAL] 
+LocalFree.restype = HLOCAL 
+ 
+class AvoidUNCPath(object): 
+    """A context manager to protect command execution from UNC paths. 
+ 
+    In the Win32 API, commands can't be invoked with the cwd being a UNC path. 
+    This context manager temporarily changes directory to the 'C:' drive on 
+    entering, and restores the original working directory on exit. 
+ 
+    The context manager returns the starting working directory *if* it made a 
+    change and None otherwise, so that users can apply the necessary adjustment 
+    to their system calls in the event of a change. 
+ 
+    Examples 
+    -------- 
+    :: 
+        cmd = 'dir' 
+        with AvoidUNCPath() as path: 
+            if path is not None: 
+                cmd = '"pushd %s &&"%s' % (path, cmd) 
+            os.system(cmd) 
+    """ 
+    def __enter__(self): 
+        self.path = os.getcwd() 
+        self.is_unc_path = self.path.startswith(r"\\") 
+        if self.is_unc_path: 
+            # change to c drive (as cmd.exe cannot handle UNC addresses) 
+            os.chdir("C:") 
+            return self.path 
+        else: 
+            # We return None to signal that there was no change in the working 
+            # directory 
+            return None 
+ 
+    def __exit__(self, exc_type, exc_value, traceback): 
+        if self.is_unc_path: 
+            os.chdir(self.path) 
+ 
+ 
+class Win32ShellCommandController(object): 
+    """Runs a shell command in a 'with' context. 
+ 
+    This implementation is Win32-specific. 
+ 
+    Example: 
+        # Runs the command interactively with default console stdin/stdout 
+        with ShellCommandController('python -i') as scc: 
+            scc.run() 
+ 
+        # Runs the command using the provided functions for stdin/stdout 
+        def my_stdout_func(s): 
+            # print or save the string 's' 
+            write_to_stdout(s) 
+        def my_stdin_func(): 
+            # If input is available, return it as a string. 
+            if input_available(): 
+                return get_input() 
+            # If no input available, return None after a short delay to 
+            # keep from blocking. 
+            else: 
+                time.sleep(0.01) 
+                return None 
+       
+        with ShellCommandController('python -i') as scc: 
+            scc.run(my_stdout_func, my_stdin_func) 
+    """ 
+ 
+    def __init__(self, cmd, mergeout = True): 
+        """Initializes the shell command controller. 
+ 
+        The cmd is the program to execute, and mergeout is 
+        whether to blend stdout and stderr into one output 
+        in stdout. Merging them together in this fashion more 
+        reliably keeps stdout and stderr in the correct order 
+        especially for interactive shell usage. 
+        """ 
+        self.cmd = cmd 
+        self.mergeout = mergeout 
+ 
+    def __enter__(self): 
+        cmd = self.cmd 
+        mergeout = self.mergeout 
+ 
+        self.hstdout, self.hstdin, self.hstderr = None, None, None 
+        self.piProcInfo = None 
+        try: 
+            p_hstdout, c_hstdout, p_hstderr, \ 
+                    c_hstderr, p_hstdin, c_hstdin = [None]*6 
+ 
+            # SECURITY_ATTRIBUTES with inherit handle set to True 
+            saAttr = SECURITY_ATTRIBUTES() 
+            saAttr.nLength = ctypes.sizeof(saAttr) 
+            saAttr.bInheritHandle = True 
+            saAttr.lpSecurityDescriptor = None 
+ 
+            def create_pipe(uninherit): 
+                """Creates a Windows pipe, which consists of two handles. 
+ 
+                The 'uninherit' parameter controls which handle is not 
+                inherited by the child process. 
+                """ 
+                handles = HANDLE(), HANDLE() 
+                if not CreatePipe(ctypes.byref(handles[0]), 
+                            ctypes.byref(handles[1]), ctypes.byref(saAttr), 0): 
+                    raise ctypes.WinError() 
+                if not SetHandleInformation(handles[uninherit], 
+                            HANDLE_FLAG_INHERIT, 0): 
+                    raise ctypes.WinError() 
+                return handles[0].value, handles[1].value 
+ 
+            p_hstdout, c_hstdout = create_pipe(uninherit=0) 
+            # 'mergeout' signals that stdout and stderr should be merged. 
+            # We do that by using one pipe for both of them. 
+            if mergeout: 
+                c_hstderr = HANDLE() 
+                if not DuplicateHandle(GetCurrentProcess(), c_hstdout, 
+                                GetCurrentProcess(), ctypes.byref(c_hstderr), 
+                                0, True, DUPLICATE_SAME_ACCESS): 
+                    raise ctypes.WinError() 
+            else: 
+                p_hstderr, c_hstderr = create_pipe(uninherit=0) 
+            c_hstdin,  p_hstdin  = create_pipe(uninherit=1) 
+ 
+            # Create the process object 
+            piProcInfo = PROCESS_INFORMATION() 
+            siStartInfo = STARTUPINFO() 
+            siStartInfo.cb = ctypes.sizeof(siStartInfo) 
+            siStartInfo.hStdInput = c_hstdin 
+            siStartInfo.hStdOutput = c_hstdout 
+            siStartInfo.hStdError = c_hstderr 
+            siStartInfo.dwFlags = STARTF_USESTDHANDLES 
+            dwCreationFlags = CREATE_SUSPENDED | CREATE_NO_WINDOW # | CREATE_NEW_CONSOLE 
+ 
+            if not CreateProcess(None, 
+                    u"cmd.exe /c " + cmd, 
+                    None, None, True, dwCreationFlags, 
+                    None, None, ctypes.byref(siStartInfo), 
+                    ctypes.byref(piProcInfo)): 
+                raise ctypes.WinError() 
+ 
+            # Close this process's versions of the child handles 
+            CloseHandle(c_hstdin) 
+            c_hstdin = None 
+            CloseHandle(c_hstdout) 
+            c_hstdout = None 
+            if c_hstderr is not None: 
+                CloseHandle(c_hstderr) 
+                c_hstderr = None 
+ 
+            # Transfer ownership of the parent handles to the object 
+            self.hstdin = p_hstdin 
+            p_hstdin = None 
+            self.hstdout = p_hstdout 
+            p_hstdout = None 
+            if not mergeout: 
+                self.hstderr = p_hstderr 
+                p_hstderr = None 
+            self.piProcInfo = piProcInfo 
+ 
+        finally: 
+            if p_hstdin: 
+                CloseHandle(p_hstdin) 
+            if c_hstdin: 
+                CloseHandle(c_hstdin) 
+            if p_hstdout: 
+                CloseHandle(p_hstdout) 
+            if c_hstdout: 
+                CloseHandle(c_hstdout) 
+            if p_hstderr: 
+                CloseHandle(p_hstderr) 
+            if c_hstderr: 
+                CloseHandle(c_hstderr) 
+ 
+        return self 
+ 
+    def _stdin_thread(self, handle, hprocess, func, stdout_func): 
+        exitCode = DWORD() 
+        bytesWritten = DWORD(0) 
+        while True: 
+            #print("stdin thread loop start") 
+            # Get the input string (may be bytes or unicode) 
+            data = func() 
+ 
+            # None signals to poll whether the process has exited 
+            if data is None: 
+                #print("checking for process completion") 
+                if not GetExitCodeProcess(hprocess, ctypes.byref(exitCode)): 
+                    raise ctypes.WinError() 
+                if exitCode.value != STILL_ACTIVE: 
+                    return 
+                # TESTING: Does zero-sized writefile help? 
+                if not WriteFile(handle, "", 0, 
+                        ctypes.byref(bytesWritten), None): 
+                    raise ctypes.WinError() 
+                continue 
+            #print("\nGot str %s\n" % repr(data), file=sys.stderr) 
+ 
+            # Encode the string to the console encoding 
+            if isinstance(data, unicode): #FIXME: Python3 
+                data = data.encode('utf_8') 
+ 
+            # What we have now must be a string of bytes 
+            if not isinstance(data, str): #FIXME: Python3 
+                raise RuntimeError("internal stdin function string error") 
+ 
+            # An empty string signals EOF 
+            if len(data) == 0: 
+                return 
+ 
+            # In a windows console, sometimes the input is echoed, 
+            # but sometimes not. How do we determine when to do this? 
+            stdout_func(data) 
+            # WriteFile may not accept all the data at once. 
+            # Loop until everything is processed 
+            while len(data) != 0: 
+                #print("Calling writefile") 
+                if not WriteFile(handle, data, len(data), 
+                        ctypes.byref(bytesWritten), None): 
+                    # This occurs at exit 
+                    if GetLastError() == ERROR_NO_DATA: 
+                        return 
+                    raise ctypes.WinError() 
+                #print("Called writefile") 
+                data = data[bytesWritten.value:] 
+ 
+    def _stdout_thread(self, handle, func): 
+        # Allocate the output buffer 
+        data = ctypes.create_string_buffer(4096) 
+        while True: 
+            bytesRead = DWORD(0) 
+            if not ReadFile(handle, data, 4096, 
+                        ctypes.byref(bytesRead), None): 
+                le = GetLastError() 
+                if le == ERROR_BROKEN_PIPE: 
+                    return 
+                else: 
+                    raise ctypes.WinError() 
+            # FIXME: Python3 
+            s = data.value[0:bytesRead.value] 
+            #print("\nv: %s" % repr(s), file=sys.stderr) 
+            func(s.decode('utf_8', 'replace')) 
+ 
+    def run(self, stdout_func = None, stdin_func = None, stderr_func = None): 
+        """Runs the process, using the provided functions for I/O. 
+ 
+        The function stdin_func should return strings whenever a 
+        character or characters become available. 
+        The functions stdout_func and stderr_func are called whenever 
+        something is printed to stdout or stderr, respectively. 
+        These functions are called from different threads (but not 
+        concurrently, because of the GIL). 
+        """ 
+        if stdout_func is None and stdin_func is None and stderr_func is None: 
+            return self._run_stdio() 
+ 
+        if stderr_func is not None and self.mergeout: 
+            raise RuntimeError("Shell command was initiated with " 
+                    "merged stdin/stdout, but a separate stderr_func " 
+                    "was provided to the run() method") 
+ 
+        # Create a thread for each input/output handle 
+        stdin_thread = None 
+        threads = [] 
+        if stdin_func: 
+            stdin_thread = threading.Thread(target=self._stdin_thread, 
+                                args=(self.hstdin, self.piProcInfo.hProcess, 
+                                stdin_func, stdout_func)) 
+        threads.append(threading.Thread(target=self._stdout_thread, 
+                                    args=(self.hstdout, stdout_func))) 
+        if not self.mergeout: 
+            if stderr_func is None: 
+                stderr_func = stdout_func 
+            threads.append(threading.Thread(target=self._stdout_thread, 
+                                        args=(self.hstderr, stderr_func))) 
+        # Start the I/O threads and the process 
+        if ResumeThread(self.piProcInfo.hThread) == 0xFFFFFFFF: 
+            raise ctypes.WinError() 
+        if stdin_thread is not None: 
+            stdin_thread.start() 
+        for thread in threads: 
+            thread.start() 
+        # Wait for the process to complete 
+        if WaitForSingleObject(self.piProcInfo.hProcess, INFINITE) == \ 
+                    WAIT_FAILED: 
+            raise ctypes.WinError() 
+        # Wait for the I/O threads to complete 
+        for thread in threads: 
+            thread.join() 
+ 
+        # Wait for the stdin thread to complete 
+        if stdin_thread is not None: 
+            stdin_thread.join() 
+ 
+    def _stdin_raw_nonblock(self): 
+        """Use the raw Win32 handle of sys.stdin to do non-blocking reads""" 
+        # WARNING: This is experimental, and produces inconsistent results. 
+        #          It's possible for the handle not to be appropriate for use 
+        #          with WaitForSingleObject, among other things. 
+        handle = msvcrt.get_osfhandle(sys.stdin.fileno()) 
+        result = WaitForSingleObject(handle, 100) 
+        if result == WAIT_FAILED: 
+            raise ctypes.WinError() 
+        elif result == WAIT_TIMEOUT: 
+            print(".", end='') 
+            return None 
+        else: 
+            data = ctypes.create_string_buffer(256) 
+            bytesRead = DWORD(0) 
+            print('?', end='') 
+ 
+            if not ReadFile(handle, data, 256, 
+                        ctypes.byref(bytesRead), None): 
+                raise ctypes.WinError() 
+            # This ensures the non-blocking works with an actual console 
+            # Not checking the error, so the processing will still work with 
+            # other handle types 
+            FlushConsoleInputBuffer(handle) 
+ 
+            data = data.value 
+            data = data.replace('\r\n', '\n') 
+            data = data.replace('\r', '\n') 
+            print(repr(data) + " ", end='') 
+            return data 
+ 
+    def _stdin_raw_block(self): 
+        """Use a blocking stdin read""" 
+        # The big problem with the blocking read is that it doesn't 
+        # exit when it's supposed to in all contexts. An extra 
+        # key-press may be required to trigger the exit. 
+        try: 
+            data = sys.stdin.read(1) 
+            data = data.replace('\r', '\n') 
+            return data 
+        except WindowsError as we: 
+            if we.winerror == ERROR_NO_DATA: 
+                # This error occurs when the pipe is closed 
+                return None 
+            else: 
+                # Otherwise let the error propagate 
+                raise we 
+ 
+    def _stdout_raw(self, s): 
+        """Writes the string to stdout""" 
+        print(s, end='', file=sys.stdout) 
+        sys.stdout.flush() 
+ 
+    def _stderr_raw(self, s): 
+        """Writes the string to stdout""" 
+        print(s, end='', file=sys.stderr) 
+        sys.stderr.flush() 
+ 
+    def _run_stdio(self): 
+        """Runs the process using the system standard I/O. 
+ 
+        IMPORTANT: stdin needs to be asynchronous, so the Python 
+                   sys.stdin object is not used. Instead, 
+                   msvcrt.kbhit/getwch are used asynchronously. 
+        """ 
+        # Disable Line and Echo mode 
+        #lpMode = DWORD() 
+        #handle = msvcrt.get_osfhandle(sys.stdin.fileno()) 
+        #if GetConsoleMode(handle, ctypes.byref(lpMode)): 
+        #    set_console_mode = True 
+        #    if not SetConsoleMode(handle, lpMode.value & 
+        #            ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT | ENABLE_PROCESSED_INPUT)): 
+        #        raise ctypes.WinError() 
+ 
+        if self.mergeout: 
+            return self.run(stdout_func = self._stdout_raw, 
+                    stdin_func = self._stdin_raw_block) 
+        else: 
+            return self.run(stdout_func = self._stdout_raw, 
+                    stdin_func = self._stdin_raw_block, 
+                    stderr_func = self._stderr_raw) 
+ 
+        # Restore the previous console mode 
+        #if set_console_mode: 
+        #    if not SetConsoleMode(handle, lpMode.value): 
+        #        raise ctypes.WinError() 
+ 
+    def __exit__(self, exc_type, exc_value, traceback): 
+        if self.hstdin: 
+            CloseHandle(self.hstdin) 
+            self.hstdin = None 
+        if self.hstdout: 
+            CloseHandle(self.hstdout) 
+            self.hstdout = None 
+        if self.hstderr: 
+            CloseHandle(self.hstderr) 
+            self.hstderr = None 
+        if self.piProcInfo is not None: 
+            CloseHandle(self.piProcInfo.hProcess) 
+            CloseHandle(self.piProcInfo.hThread) 
+            self.piProcInfo = None 
+ 
+ 
+def system(cmd): 
+    """Win32 version of os.system() that works with network shares. 
+ 
+    Note that this implementation returns None, as meant for use in IPython. 
+ 
+    Parameters 
+    ---------- 
+    cmd : str 
+      A command to be executed in the system shell. 
+ 
+    Returns 
+    ------- 
+    None : we explicitly do NOT return the subprocess status code, as this 
+    utility is meant to be used extensively in IPython, where any return value 
+    would trigger :func:`sys.displayhook` calls. 
+    """ 
+    with AvoidUNCPath() as path: 
+        if path is not None: 
+            cmd = '"pushd %s &&"%s' % (path, cmd) 
+        with Win32ShellCommandController(cmd) as scc: 
+            scc.run() 
+ 
+ 
+if __name__ == "__main__": 
+    print("Test starting!") 
+    #system("cmd") 
+    system("python -i") 
+    print("Test finished!")