Utilice el módulo de subproceso Python 2.6 en Python 2.5




subprocess python-2.5 (4)

Bueno, Python es de código abierto, puedes tomar esa función pthread desde 2.6 y moverla a tu propio código o utilizarla como referencia para implementar la tuya.

Por razones que deberían ser obvias, no hay forma de tener un híbrido de Python que pueda importar porciones de versiones más nuevas.

Me gustaría usar la versión del subproceso de Python 2.6, porque permite la función Popen.terminate () , pero estoy atrapado con Python 2.5. ¿Hay alguna forma razonablemente limpia de usar la versión más nueva del módulo en mi código 2.5? Algún tipo de from __future__ import subprocess_module ?


Realmente no hay una gran manera de hacerlo. El subproceso se implementa en python (en lugar de C) por lo que podría posiblemente copiar el módulo en alguna parte y usarlo (con la esperanza, por supuesto, de que no use ninguna bondad 2.6).

Por otro lado, usted podría simplemente implementar lo que afirma hacer en el subproceso y escribir una función que envíe SIGTERM en * nix y llame a TerminateProcess en Windows. La siguiente implementación se ha probado en Linux y en una Win XP vm, necesitará las extensiones de Windows de Python :

import sys

def terminate(process):
    """
    Kills a process, useful on 2.5 where subprocess.Popens don't have a 
    terminate method.


    Used here because we're stuck on 2.5 and don't have Popen.terminate 
    goodness.
    """

    def terminate_win(process):
        import win32process
        return win32process.TerminateProcess(process._handle, -1)

    def terminate_nix(process):
        import os
        import signal
        return os.kill(process.pid, signal.SIGTERM)

    terminate_default = terminate_nix

    handlers = {
        "win32": terminate_win, 
        "linux2": terminate_nix
    }

    return handlers.get(sys.platform, terminate_default)(process)

De esta forma, solo debe mantener el código de terminate lugar del módulo completo.


Si bien esto no responde directamente a su pregunta, puede valer la pena saberlo.

Las importaciones de __future__ realidad solo cambian las opciones del compilador, de modo que si bien puede convertirse en una declaración o hacer que los literales de cadena produzcan unicodes en lugar de strs, no puede cambiar las capacidades y características de los módulos en la biblioteca estándar de Python.


Aquí hay algunas maneras de finalizar procesos en Windows, tomados directamente de http://code.activestate.com/recipes/347462/

# Create a process that won't end on its own
import subprocess
process = subprocess.Popen(['python.exe', '-c', 'while 1: pass'])


# Kill the process using pywin32
import win32api
win32api.TerminateProcess(int(process._handle), -1)


# Kill the process using ctypes
import ctypes
ctypes.windll.kernel32.TerminateProcess(int(process._handle), -1)


# Kill the proces using pywin32 and pid
import win32api
PROCESS_TERMINATE = 1
handle = win32api.OpenProcess(PROCESS_TERMINATE, False, process.pid)
win32api.TerminateProcess(handle, -1)
win32api.CloseHandle(handle)


# Kill the proces using ctypes and pid
import ctypes
PROCESS_TERMINATE = 1
handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False, process.pid)
ctypes.windll.kernel32.TerminateProcess(handle, -1)
ctypes.windll.kernel32.CloseHandle(handle)






python-2.5