FM / multiprocessing

/opt/alt/python35/lib64/python3.5/multiprocessing/

/opt/alt/python35/lib64/python3.5/multiprocessing

Name	Size	Mode	Actions
dummy/	-	0755	rm
__pycache__/	-	0755	rm
connection.py	30857	0644	edit dl rm
context.py	10677	0644	edit dl rm
forkserver.py	8214	0644	edit dl rm
heap.py	8325	0644	edit dl rm
managers.py	35963	0644	edit dl rm
pool.py	25819	0644	edit dl rm
popen_fork.py	2327	0644	edit dl rm
popen_forkserver.py	1967	0644	edit dl rm
popen_spawn_posix.py	1915	0644	edit dl rm
popen_spawn_win32.py	2998	0644	edit dl rm
process.py	9136	0644	edit dl rm
queues.py	10751	0644	edit dl rm
reduction.py	8108	0644	edit dl rm
resource_sharer.py	5318	0644	edit dl rm
semaphore_tracker.py	4820	0644	edit dl rm
sharedctypes.py	6228	0644	edit dl rm
spawn.py	8860	0644	edit dl rm
synchronize.py	12052	0644	edit dl rm
util.py	11641	0644	edit dl rm
__init__.py	923	0644	edit dl rm

Edit: /opt/alt/python35/lib64/python3.5/multiprocessing/popen_spawn_win32.py (2998B)

import os
import msvcrt
import signal
import sys
import _winapi

from . import context
from . import spawn
from . import reduction
from . import util

__all__ = ['Popen']

#
#
#

TERMINATE = 0x10000
WINEXE = (sys.platform == 'win32' and getattr(sys, 'frozen', False))
WINSERVICE = sys.executable.lower().endswith("pythonservice.exe")

#
# We define a Popen class similar to the one from subprocess, but
# whose constructor takes a process object as its argument.
#

class Popen(object):
    '''
    Start a subprocess to run the code of a process object
    '''
    method = 'spawn'

def __init__(self, process_obj):
        prep_data = spawn.get_preparation_data(process_obj._name)

# read end of pipe will be "stolen" by the child process
        # -- see spawn_main() in spawn.py.
        rhandle, whandle = _winapi.CreatePipe(None, 0)
        wfd = msvcrt.open_osfhandle(whandle, 0)
        cmd = spawn.get_command_line(parent_pid=os.getpid(),
                                     pipe_handle=rhandle)
        cmd = ' '.join('"%s"' % x for x in cmd)

with open(wfd, 'wb', closefd=True) as to_child:
            # start process
            try:
                hp, ht, pid, tid = _winapi.CreateProcess(
                    spawn.get_executable(), cmd,
                    None, None, False, 0, None, None, None)
                _winapi.CloseHandle(ht)
            except:
                _winapi.CloseHandle(rhandle)
                raise

# set attributes of self
            self.pid = pid
            self.returncode = None
            self._handle = hp
            self.sentinel = int(hp)
            util.Finalize(self, _winapi.CloseHandle, (self.sentinel,))

# send information to child
            context.set_spawning_popen(self)
            try:
                reduction.dump(prep_data, to_child)
                reduction.dump(process_obj, to_child)
            finally:
                context.set_spawning_popen(None)

def duplicate_for_child(self, handle):
        assert self is context.get_spawning_popen()
        return reduction.duplicate(handle, self.sentinel)

def wait(self, timeout=None):
        if self.returncode is None:
            if timeout is None:
                msecs = _winapi.INFINITE
            else:
                msecs = max(0, int(timeout * 1000 + 0.5))

res = _winapi.WaitForSingleObject(int(self._handle), msecs)
            if res == _winapi.WAIT_OBJECT_0:
                code = _winapi.GetExitCodeProcess(self._handle)
                if code == TERMINATE:
                    code = -signal.SIGTERM
                self.returncode = code

return self.returncode

def poll(self):
        return self.wait(timeout=0)

def terminate(self):
        if self.returncode is None:
            try:
                _winapi.TerminateProcess(int(self._handle), TERMINATE)
            except OSError:
                if self.wait(timeout=1.0) is None:
                    raise

cmd: