Odtnhj

So I have a completely independent process, with a known PID.

I want to send it some kind of interrupt from another unrelated process that will cause it to 'gracefully' exit.

In linux it would look something like this :

first_script:

def signal_handler(signum, stack):
 print("SIGNAL RECIEVED")
 sys.exit()

signal.signal(signal.SIGUSR1, handle_signal)
while True:
 print("Im working")

Second script:

known_pid = input("Enter pid")
os.kill(int(known_pid), signal.SIGUSR1)

Since, Windows doesn't support signaling in this way, it obviously won't work but I couldn't find any other simple solution (After quite extensive research).

You can use the Windows API as provided by pywin32 or hack it with a socket.

The socket solution is quick and dirty:

# waiting process

import socket
import select
import time

server = socket.socket()
server.bind(('localhost', 1337))
server.listen(5)

# this select() call returns ([server], , )
# if server is readable, else (, , ), and waits 0 seconds
while not select.select([server], , , 0)[0]:
 print('working')
 time.sleep(0.5)


# parent process

import socket 
socket.create_connection(('localhost', 1337))

The windows solution is longer but more accurately represents the problem:

# waiting process

import time
import win32event

# open an existing event by name with the required access
# (didn't work for me with EVENT_MODIFY_STATE, got "Access denied" error)
event = win32event.OpenEvent(win32event.EVENT_ALL_ACCESS, 0, "MY_NAME")

# Wait 0 seconds on the event. If event has been set, WAIT_OBJECT_0 is returned
while win32event.WaitForSingleObject(event, 0) != win32event.WAIT_OBJECT_0:
 print('working')
 time.sleep(0.5)


# parent process
# note that it should be run first

import win32event
import time

# create event by name
event = win32event.CreateEvent(
 None, # not inherited by child processes
 False, # auto-reset the event after it is set
 False, # created unset
 "MY_NAME", # event name
)
time.sleep(5) # wait for waiting process to start
win32event.SetEvent(event)

This is only a minimal POC. It is recommended that you read about event objects to find the exact solution that suits you.

How about consider using psutil, I think it is quite suitable for your case.

As stated in document, following code can do what you want. Though you may not need the part of find_procs_by_name.

import os
import signal
import psutil

def find_procs_by_name(name):
 "Return a list of processes matching 'name'."
 ls = 
 for p in psutil.process_iter(attrs=["name", "exe", "cmdline"]):
 if name == p.info['name'] or 
 p.info['exe'] and os.path.basename(p.info['exe']) == name or 
 p.info['cmdline'] and p.info['cmdline'][0] == name:
 ls.append(p)
 return ls

def kill_proc_tree(pid, sig=signal.SIGTERM, include_parent=True,
 timeout=None, on_terminate=None):
 """Kill a process tree (including grandchildren) with signal
 "sig" and return a (gone, still_alive) tuple.
 "on_terminate", if specified, is a callabck function which is
 called as soon as a child terminates.
 """
 if pid == os.getpid():
 raise RuntimeError("I refuse to kill myself")
 parent = psutil.Process(pid)
 children = parent.children(recursive=True)
 if include_parent:
 children.append(parent)
 for p in children:
 p.send_signal(sig)
 gone, alive = psutil.wait_procs(children, timeout=timeout,
 callback=on_terminate)
 return (gone, alive)

pid = find_procs_by_name('POWERPNT.EXE')[0].pid
print(find_procs_by_name('POWERPNT.EXE')[0].pid)
kill_proc_tree(pid)