semvec/pypi-packages huggingface dataset:
simple-launch-process 0.1.1
Client library for simple-launch
License: Apache-2.0
Requires Python: >=3.6

# Simple Launch Process

This library contains client utility functions for processes launched using `simple-launch`, although they may also be used without `simple-launch`. Currently this package provides a reliable way for processes to receive shutdown signals from a process manager or the user using `ctrl-c`.

See `simple-launch`: https://github.com/johnwason/simple-launch

## Installation

```
python -m pip install --user simple-launch-process
```

On Ubuntu, it may be necessary to replace `python` with `python3`.

## Usage

The module contains three functions:

* `simple_launch_process.wait_exit()` - Block and wait for exit
* `simple_launch_process.wait_exit_callback(callback)` - Return immediately and call `callback()` when shutdown signal received
* `simple_launch_process.wait_exit_stop_loop(loop)` - Call to stop an `asyncio` loop when shutdown signal received

## Example

A simple example of running a Python http server in a background thread, using the blocking `wait_exit()`.

```python
import simple_launch_process
import threading
from http import server as http_server

server=http_server.ThreadingHTTPServer(('',8085), 
        http_server.SimpleHTTPRequestHandler)
def run_server():
    server.serve_forever()

th = threading.Thread(target=run_server)
th.daemon = True
th.start()

simple_launch_process.wait_exit()
```

This example uses the callback version to quit the http server:

```python
import simple_launch_process
import threading
from http import server as http_server

server=http_server.ThreadingHTTPServer(('',8085), 
        http_server.SimpleHTTPRequestHandler)

def shutdown_server():
    server.shutdown()

simple_launch_process.wait_exit_callback(shutdown_server)

server.serve_forever()
```

## Shutdown Signal Explanation

Reliably sending a shutdown/quit command to a process in a cross-platform manner is surprisingly difficult. On POSIX based systems like Linux and Mac OS X, signals such as `SIGINT` or `SIGTERM` are typically sent. (Ctrl-C sends `SIGINT`). These signals can be caught by the process, and used to gracefully shut down. `SIGKILL` is used to immediately terminate the process.

On Windows, it is significantly more difficult. Windows typically uses "Window Message Queues" to communicate with processes. Even processes like services that do not have a visible window often have a hidden window so messages can be received from the operating system. There is some functionality for sending console signals, but these are not reliable for all cases. Windows also has the concept of `Job Objects` that can be used to group different processes together. The combination of job objects and windows messages provide a reliable way to send and receive graceful shutdown signals.

The `wait_for_exit*` commands either way for Signals on POSIX, or windows close messages and console events on Windows.