Popular recipes tagged "meta:requires=thread"

Persistent Queue (Python)

2015-11-12T06:45:12-08:00

Python recipe 579124 by zhangkaizhao (sysadmin).

A class for persistent queues.

Ordered Dictionary for Py2.4 (Python)

2011-04-24T03:20:45-07:00

Python recipe 576693 by Raymond Hettinger (dictionary, linked_list, ordered). Revision 9.

Drop-in substitute for Py2.7's new collections.OrderedDict. The recipe has big-oh performance that matches regular dictionaries (amortized O(1) insertion/deletion/lookup and O(n) iteration/repr/copy/equality_testing).

Calendar Maker (Python)

2012-07-03T05:23:57-07:00

Python recipe 578187 by Stephen Chappell (archive, calendar, cgi, old).

This is an old program experimenting with CGI techniques in Python using CGIHTTPServer and designed for creating calendars. This is committed for archival to be run under Python 2.5 or later versions.

Distributed lock manager for Python (Python)

2012-07-04T21:03:32-07:00

Python recipe 578194 by pavel (distributed, lock, locking, locks, manager, socket, thread, threading, wsgi). Revision 2.

Distributed lock manager provides mutex(es) over network. It is used to synchronize processes running on different machines, e.g. WSGI processes in case of web applications. Lock object is compatible with threading.Lock and can be used as a context manager ("with statement"). It can be easily modified to use UNIX sockets instead of TCP/IP. Communication protocol is text based.

First start server process:

$ chmod +x dlm.py
$ ./dlm.py

Usage:

from dlm import LockClient

client = LockClient('localhost', 27272, 'client_name')

lock = client.mkLock('lock_name')

lock.acquire()
# critical section here...
lock.release()

# using context manager
with lock:
    # critical section here...

Yet Another Ordered Dictionary (Python)

2011-08-07T12:14:56-07:00

Python recipe 577826 by Lucio Santi (dict, dictionary, linked_list, ordered).

An implementation of dictionaries preserving key insertion order. Despite using a doubly-linked list to keep track of the appropriate order, this list is actually embedded in the dictionary. As a consequence, there is little space penalty, and also every operation exhibits an efficient implementation (i.e., no need to perform lookups or deletions multiple times, as it happens with other versions of this data structure).

Trace decorator for debugging (Python)

2011-01-24T18:40:51-08:00

Python recipe 577551 by Kevin L. Sitze (classes, debug, debugging, decorators, functions, inspection, modules, trace). Revision 2.

This package provides a decorator for tracing function and method calls in your applications. The tracing capabilities are managed through the logging package, and several mechanisms are provided for controlling the destination of the trace output.

It also provides functionality for adding decorators to existing classes or modules.

PluginManager - Extending Project Functionality By Using Custom Modules/Plugins On The Fly. (Python)

2010-05-07T15:32:10-07:00

Python recipe 577216 by AJ. Mayorga (extending, extensible, modules, plugin). Revision 4.

This demo shows how you can create and manage your own custom plugins for extending functionality in your Python projects. There are no safety wrappers in this demo for restricting plugins aside from that fact that plugins are run as an extention of a management class which is run in its own instance only receiving data passed to it by the RumModules method, that said security should ideally be applied to the ModuleAPI class, by restricting __builtins__ on eval calls and/or validating plugin content and parameters which can be done by extending the Prepaser Class. For a great recipe/demo of restricting eval call see http://code.activestate.com/recipes/496746.

That aside it was alot of fun to write and use. Enjoy

PS: you will need http://code.activestate.com/recipes/577144/ to import Xceptions

Thread pool with same API as (multi)processing.Pool (Python)

2016-01-30T00:40:20-08:00

Python recipe 576519 by david decotigny (multiprocessing, pool, processing, thread). Revision 10.

There are probably <write your guess here>s of recipes presenting how to implement a pool of threads. Now that multiprocessing is becoming mainstream, this recipe takes multiprocessing.Pool as a model and re-implements it entirely with threads. Even the comments should look familiar... This recipe also adds 2 new methods: imap_async() and imap_unordered_async().

Multithreaded Multiplexer/Demultiplexer to allow multiple transactions to be performed in parallel on a single channel (Python)

2008-10-04T00:12:00-07:00

Python recipe 576520 by david decotigny (demultiplexer, multiplexer, thread, transaction). Revision 8.

Imagine you have one wire and you want to send a message from a machine A to another machine B, and wait for an answer from B (a "request/response transaction" in the following). Now imagine you have many threads on A which can make this kind of transaction "simultaneously", then you have to be cautious, otherwise you might get the wrong responses for your transactions. One solution is to serialize the transactions: the threads on A will have to wait for their turn to make their request/response transaction.

Another solution is to map a thread requesting a transaction on A, to a thread handling it on B. This allows for several transactions to be in flight at the same time on the same wire. This is what this module does: on A lives a multiplexer and threads call its transaction() method to initiate the request/response. On B, process_transaction() of a demultiplexer will get called by worker threads. All this in a multi-threaded way on a single wire. The module takes care of managing the interleaving requests/responses.

CallPipe: Call the methods of an object in a remote process (Python)

2008-09-17T17:33:36-07:00

Python recipe 576509 by david decotigny (call, multiprocessing, pipe, processing, remote). Revision 6.

I am process A and I own object Obj. Now I decide to fork(): process B is born.

How do I do to make process B call the methods of A's object Obj (and not the methods of its own copy of Obj...) ?

This is what this module does: you create the "CallPipe" for Obj prior to fork()ing, and then process B can call any method of A's object Obj through it.

Threaded Documenting XML RPC server over HTTPS (Python)

2008-06-06T16:59:23-07:00

Python recipe 573444 by Andrew Yinger (web). Revision 4.

Server that runs a threaded, documenting XMLRCP server that uses HTTPS for transporting XML data.

(This code borrow's heavily from Laszlo Nagy's: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496786)

Easy testing of CGI scripts (Python)

2016-11-01T02:27:13-07:00

Python recipe 550822 by Bryan Olson (cgi). Revision 3.

Invoking 'runcgi.py target.cgi' starts a built-in web server listening on the localhost adapter, configures the server to run target.cgi as a CGI program, then launches the system's default web browser to get the URL of the target script. The CGI script need not be in Python. The terminal that launched runcgi.py will show the server's log, which reports requests, responses, and errors.

Submit multiple concurrent batch jobs, with flexible throttling and timing. (Python)

2007-11-11T10:33:36-08:00

Python recipe 534160 by Mark Pettit (sysadmin).

Submit a series of batch commands (as expected by the os.system() function). Each will be submitted in a separate python thread, but will be a separate process, hence will take advantage of multi-core cpu's. A maximum number of simultaneous jobs can be set - throttling. A maximum time can be set before the routine will return, else it waits until all are completed.

Paint 2.0 (Python)

2007-03-28T15:30:34-07:00

Python recipe 511436 by Stephen Chappell (graphics).

This program was adapted from the SAMPLES directory that comes with Python. It allows two people to draw on a program with someone else watching and, at the same time watch what the other person is drawing also.

Paint 1.0 (Python)

2007-03-28T15:21:48-07:00

Python recipe 511434 by Stephen Chappell (graphics).

spots (V2) (Python)

2007-03-28T15:28:58-07:00

Python recipe 511435 by Stephen Chappell (network).

This recipe is the core of something called FDR (Full Duplex RPC). FDR has not been completed at this time, but the "spots" module takes most of the work off of other modules in network chatter. This is the second version of "spots" and simplifies the ZSP class while getting rid of the base255 module.

Restricted "safe" eval (Python)

2006-05-29T20:08:35-07:00

Python recipe 496746 by Babar K. Zafar . Revision 3.

Provides a retricted enviroment for dynamically executing a subset of the Python language suitable for configuration scripts, end-user oriented scripting and storing data in a user-friendly way.

spots (V1) (Python)

2007-03-28T15:17:45-07:00

Python recipe 511433 by Stephen Chappell (network).

This program demonstrates some sample usage of the base255 module and is the core of something called FDR (Full Duplex RPC). FDR has not been completed at this time, but the "spots" module takes most of the work off of other modules in network chatter.

Module For Running Simple Proxies (Python)

2007-02-01T21:51:53-08:00

Python recipe 502204 by Stephen Chappell (network).

Proxies can be useful at times but may not be simple to create and run. This recipe provides a single class that can build proxy objects capable of being both started and stopped.

Persistent Queue (Python)

2007-06-27T11:43:13-07:00

Python recipe 501154 by Kjetil Jacobsen (sysadmin). Revision 2.

A class for persistent queues.