Popular recipes tagged "process" but not "cards"

Monitor Progress of File Descriptors of Another Process (Python)

2014-05-30T01:10:53-07:00

Python recipe 578882 by Alfe (file_descriptor, monitor, prediction, proc, process, progress, watch).

This tool (inspired by azat@stackoverflow, see http://stackoverflow.com/a/16082562/1281485) allows to watch the progress of the file descriptors of another process. This can be used, for example, if you transfer a file to another host and the transferring program does not show any progress indication itself. Instead of waiting blindly until the routine is done, with this tool you can use Linux's proc file system to monitor the progress of the other process while it walks through the file.

The tool continuously monitors the position in and the size of the files the given process's file descriptors point to. For growing (or shrinking, but that's very unusual) files, a time when it was (or will be) empty is computed ("emptyTime"), for moving file descriptors (the typical case), the time when it started at position 0 ("startTime"), the time when it will reach the current size of the file ("reachTime") and when it will meet with the end of a growing (or shrinking) file is computed ("meetTime").

For fixed-size files the meetTime will be the same as the reachTime of course. The meetTime only makes sense in case a file is growing and at the same time read (e. g. when a movie is downloaded to a file by one process and converted by a different process; using this tool can tell you when the converter process might run dry on the input because the download wasn't fast enough, and in this case you maybe can pause the converter to prevent this situation).

The tool is designed as a library; the display of the information is independent from the gathering of the data. Please feel free to create more fancy displays, add percentage output etc.

Get memory usage of Windows processes using GetProcessMemoryInfo (via ctypes) (Python)

2013-04-25T01:26:19-07:00

Python recipe 578513 by Ben Hoyt (ctypes, memory, process, win32, windows).

These functions call the Win32 function GetProcessMemoryInfo() using ctypes to get the memory usage of the current process. Works on both 32-bit and 64-bit Windows and Python 2.6+ (including Python 3.x).

xdiff in python (Python)

2012-11-12T20:59:54-08:00

Python recipe 578324 by Hiro (file, process). Revision 2.

xdiff.py compares and output difference of file1 and file2. it finds out the lines that are unique in file1 and files2, the finding is written to file3 and file4 respectively.

Get parent process pid win32 (Python)

2012-05-15T18:01:22-07:00

Python recipe 578133 by nuumio (process, process_management).

Use ctypes + Win32 functions to enumerate processes and find parent process id.

Thanks to winterTTr Dong for the original recipe.

Wait for PID and check for PID existance (POSIX) (Python)

2012-04-15T14:13:02-07:00

Python recipe 578022 by Giampaolo Rodolà (exists, exit, pid, process, status, timeout, wait). Revision 7.

Two functions: one which waits for a certain PID to terminate (with optional timeout), another one which checks whether a process with a given PID is running.

This was extracted from psutil project which also provides a Windows implementation.

Timeout functionality is implemented as a busy loop and it was inspired by http://bugs.python.org/issue5673.

Generic way to create a daemonized process in python (Python)

2012-03-26T14:56:17-07:00

Python recipe 578072 by ajaymenon.k (daemon, process, threads). Revision 4.

A simple daemon that will constantly keep track the size of your inbox and when it exceeds a certain size, will send you a reminder email.

Win32 named mutex class for system-wide mutex (Python)

2011-07-15T21:12:40-07:00

Python recipe 577794 by Ben Hoyt (ctypes, lock, mutex, process, threading, win32, windows).

NamedMutex is a class for using Windows (Win32) named mutexes for system-wide locks. For example, we use these to lock system-wide log files that multiple processes can write to.

Sleepsort with processes and pipes (Python)

2011-06-17T02:37:58-07:00

Python recipe 577758 by Benjamin Peterson (process, sorting, unix). Revision 2.

Sleepsort is a sorting algorithm that uses the system sleep syscall in a very creative fashion.

This is the same algorithm as recipe 577756 but using *nix processes instead of threads.

Simple way to execute multiple process in parallel (Python)

2010-08-31T00:11:00-07:00

Python recipe 577376 by Benjamin Sergeant (multiprocessing, process). Revision 4.

Does not require multiprocessing, easy to hack, maybe not optimal but did the job for a make like tool I wrote.

Multiprocess-safe logging file-handler + interprocess RLock (Python)

2010-09-22T17:30:10-07:00

Python recipe 577395 by Jan Kaliszewski (concurrency, file, file_lock, flock, handler, logging, process, rlock, threading, threadsafe). Revision 11.

A Python 2.x/3.x-compatibile multiprocess-safe logging file-handler (logging.FileHandler replacement, designed for logging to a single file from multiple independent processes) together with a simple interprocess recursive lock -- universal abstract classes + Unix/Linux implementation.

Update: It's is a deeply revised version. Especially, now it --

is Python 2.4, 2.5, 2.6, 3.1 -compatibile (previously Py>=2.6 was needed); probably works also with 2.7, 3.0 and 3.2 (but not tested if it does);
is multiprocess-safe as well as thread-safe (proviously thread safety within a process was missed);
is based on public interfaces only (previously FileHandler._open() was called and overriden);
implement full RLock instance interface, as documented for threading.RLock (previously non-blocking mode and context-manager interface were missing).

The module contains:

Unix/Linux-only example implementation (with flock-based locking): FLockRLock and FLockFileHandler classes.
universal abstract classes -- which may be useful at developing implementation for non-Unix platforms: MultiprocessRLock, MultiprocessFileHandler, LockedFileHandler,

Also a quick-and-dirty test was added.

It is still an alpha version -- I'll be very grateful for any feedback.

Further updates:

2010-09-20: Some corrections, especially: non-blocking mode bug in MultiprocessRLock.acquire() fixed; _test() function improved; plus fixes in the description below.
2010-09-22: _test() improved and moved to description section. Mistaken copyright-notice removed.

fcntl.flock() (Unix file lock) behaviour sampling script (Python)

2010-09-22T00:11:12-07:00

Python recipe 577404 by Jan Kaliszewski (file, file_descriptor, file_lock, flock, process, thread). Revision 3.

A quick fcntl.flock(fcntl.LOCK_EX | fcntl.LOCK_NB) call sampling script: with one file object (and descriptor) or separate file objects (and different descriptors) pointing to the same filesystem path -- with/without threading or forking.

It's rather exemplum-and-educational piece of code than utility-script, unless somebody has to few slots in their memory to remember that flock is file-descriptor-tacked (then quick run of the script can save web-searching) :)

Decoupled Proxy of a State Bearing Object in a Multiprocessing Environment (Python)

2010-04-08T04:36:05-07:00

Python recipe 577180 by Mateyuzo (access, multiprocessing, process, processing, subprocess, synchronization, syncmanager, threading, __getattribute__). Revision 2.

Describes a simple example of the potential for shared Singleton or Borg object methods to be proxy'd by an object that SyncManger can present to requesting subprocesses.

Timeout Any Function (Python)

2010-02-04T17:36:31-08:00

Python recipe 577028 by Stephen Chappell (asynchronous, generic, process, timeout, universal_code). Revision 6.

This recipe uses the multiprocessing module to kill functions that have run longer than intended. Unlike other recipes that use threading, this code is designed to actually kill execution that has continued for too long. This implementation does not rely on signals or anything that is OS specific, so it should work on any system on which you might need generic timeouts.

Super Shorcuts for Windows (Python)

2009-04-26T11:09:39-07:00

Python recipe 576730 by Akira Fora (process, windows, wmi).

This script allows one to launch or kill several applications at once. It works on MS Windows.

Run a function in a separate (forked) process without blocking (Python)

2008-02-28T22:22:18-08:00

Python recipe 550801 by Gary Eakins (fork, mmap, process). Revision 2.

A procedure that runs a function asynchronously in a forked process (Availability: Macintosh, Unix). The return from the specified function is written into an anonymous memory map (mmap: requires +Python 2.5). This can be useful for releasing resources used by the function such as memory, updating a gui or cli widget, or other weirdness.

An Erlang Port in Python (Python)

2010-02-18T06:47:09-08:00

Python recipe 534162 by thanos vassilakis (distributed, erlang, integration, process). Revision 3.

Erlang has two built-in interoperability mechanisms. One is distributed Erlang nodes and the other one is ports. Ports provide the basic Erlang mechanism for communication with the external world. They provide a byte-oriented interface to an external program. When a port has been created, Erlang can communicate with it by sending and receiving lists of bytes. This recipe cooks an Erlang port in python. Making it easy for Erlang to instantiate and use python objects. Like most simple port implementations it uses an external python program and lets Erlang communicate via standard input and write to standard output. Theoretically, the external program could be written in any programming language. This recipe is pretty abstract and you will have to implement your own encode and decoding scheme.