Top-rated recipes tagged "meta:requires=os"

Creating a daemon the Python way (Python)

2005-10-03T16:49:09-07:00

Python recipe 278731 by Chad J. Schroeder (threads). Revision 6.

The Python way to detach a process from the controlling terminal and run it in the background as a daemon.

Sorting big files the Python 2.4 way (Python)

2006-04-13T10:43:13-07:00

Python recipe 466302 by Nicolas Lehuen (files). Revision 6.

This recipe can be used to sort big files (much bigger than the available RAM) according to a key. The sort is guaranteed to be stable on Python 2.3.

Module to allow Asynchronous subprocess use on Windows and Posix platforms (Python)

2006-12-01T17:30:02-08:00

Python recipe 440554 by Josiah Carlson (sysadmin). Revision 10.

The 'subprocess' module in Python 2.4 has made creating and accessing subprocess streams in Python relatively convenient for all supported platforms, but what if you want to interact with the started subprocess? That is, what if you want to send a command, read the response, and send a new command based on that response?

Now there is a solution. The included subprocess.Popen subclass adds three new commonly used methods: recv(maxsize=None), recv_err(maxsize=None), and send(input), along with a utility method: send_recv(input='', maxsize=None).

recv() and recv_err() both read at most maxsize bytes from the started subprocess. send() sends strings to the started subprocess. send_recv() will send the provided input, and read up to maxsize bytes from both stdout and stderr.

If any of the pipes are closed, the attributes for those pipes will be set to None, and the methods will return None.

v. 1.3 fixed a few bugs relating to *nix support v. 1.4,5 fixed initialization on all platforms, a few bugs relating to Windows support, added two utility functions, and added an example of how to use this module. v. 1.6 fixed linux _recv() and test initialization thanks to Yuri Takhteyev at Stanford. v. 1.7 removed _setup() and __init__() and fixed subprocess unittests thanks to Antonio Valentino. Added 4th argument 'tr' to recv_some(), which is, approximately, the number of times it will attempt to recieve data. Added 5th argument 'stderr' to recv_some(), where when true, will recieve from stderr. Cleaned up some pipe closing. v. 1.8 Fixed missing self. parameter in non-windows _recv method thanks to comment. v. 1.9 Fixed fcntl calls for closed handles.

Fork a daemon process on Unix (Python)

2001-07-10T14:01:38-07:00

Python recipe 66012 by Jürgen Hermann (threads).

Forking a daemon on Unix requires a certain sequence of system calls. Since Python exposes a full POSIX interface, this can be done in Python, too.

Persistent dict with multiple standard file formats (Python)

2011-09-06T20:01:46-07:00

Python recipe 576642 by Raymond Hettinger (dbm, dictionary, persistent, shelve). Revision 10.

dbdict: a dbm based on a dict subclass.

On open, loads full file into memory. On close, writes full dict to disk (atomically). Supported output file formats: csv, json, and pickle. Input file format automatically discovered.

Usable by the shelve module for fast access.

PyDbLite, a small in-memory database engine (Python)

2011-07-18T19:36:04-07:00

Python recipe 496770 by Pierre Quentel (database). Revision 4.

A small, fast, in-memory database management program

The database object supports the iterator protocol, so that requests can be expressed with list comprehensions or generator expressions instead of SQL. The equivalent of :

cursor.execute("SELECT name FROM table WHERE age=30")
rows = cursor.fetchall()

is :

rows = table(age=30)

The module stores data in a cPickled file. Records are indexed by a unique record identifier, that can be used for direct access. Since operations are processed in memory they are extremely fast, nearly as fast as SQLite in the few tests I made, and MUCH faster than other pure-Python modules such as Gadfly or KirbyBase. An index can be created on a field to even speed up selections

Concurrency control is supported by a version number set for each record

Complete documentation is here

Simple HTTP server supporting SSL secure communications (Python)

2008-08-02T16:04:56-07:00

Python recipe 442473 by Sebastien Martini (https, openssl, ssl, web). Revision 8.

This recipe describes how to set up a simple HTTP server supporting SSL secure communications. It extends the SimpleHTTPServer standard module to support the SSL protocol. With this recipe, only the server is authenticated while the client remains unauthenticated (i.e. the server will not request a client certificate). Thus, the client (typically the browser) will be able to verify the server identity and secure its communications with the server.

This recipe requires you already know the basis of SSL and how to set up OpenSSL. This recipe is mostly derived from the examples provided with the pyOpenSSL package.

In order to apply this recipe, follow these few steps:

Install the OpenSSL package in order to generate key and certificate. Note: you probably already have this package installed if you are under Linux, or *BSD.
Install the pyOpenSSL package, it is an OpenSSL library binding. You'll need to import this module for accessing OpenSSL's components.
Generate a self-signed certificate compounded of a certificate and a private key for your server with the following command (it outputs them both in a single file named server.pem): openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes
Assuming you saved this recipe in SimpleSecureHTTPServer.py, start the server (with the appropriate rights): python SimpleSecureHTTPServer.py
Finally, browse to https://localhost, or https://localhost:port if your server listens a different port than 443.

firefox sqlite files cleaner (Python)

2009-07-18T21:41:13-07:00

Python recipe 576842 by peekaa (firefox, sqlite). Revision 7.

Walks through the all the Firefox profiles in current user account and cleans all *.sqlite files with "vacuum". It makes firefox faster then often. Should work on Linux, too, when properly changed constants.

For: python 2.6 (2.5+sqlite3), FF 3.5

Povray for python (Python)

2003-06-13T21:22:18-07:00

Python recipe 205451 by Simon Burton (graphics).

Here is a relatively simple framework for making povray files from your favourite programming language, python. It's good for creating structured/mathematical scenes and animations.

Finite State Machine (FSM) (Python)

2007-12-05T01:25:49-08:00

Python recipe 146262 by Noah Spurrier (algorithms). Revision 2.

This recipe shows a Finite State Machine (FSM) that can be used for small parsing tasks. The code is quite simple. The bulk of it is comments. In addition to state this FSM also maintains a user defined "memory". So this FSM is a Push-down Automata (PDA) since a PDA is a FSM + memory. This module contains an example function that demonstrates a simple RPN expression evaluator.

Send HTML or Text email with or without attachments (Python)

2009-07-27T13:14:24-07:00

Python recipe 576858 by Isaac Wagner (email, smtp).

Using code gleaned from the net and from my own brain I created this convenient wrapper to send email messages via SMTP in Python. This class allows you to send plain text email messages or HTML encoded messages. You can also add attachments to the messages.

PathCatcher - Windows utility for right-click capture of file or folder path (Python)

2008-04-19T17:14:18-07:00

Python recipe 528893 by Jack Trainor (shortcuts). Revision 3.

PathCatcher is a Windows utility that allows one to right-click on a file or a folder or a group of files and folders in Explorer and save its path to the clipboard.

To install, save the code as PathCatcher.py, then double-click the PathCatcher.py file. Afterwards, PathCatcher will appear in the Explorer right-click menu.

My first application server (Python)

2009-02-23T11:53:57-08:00

Python recipe 392879 by Pierre Quentel (web). Revision 8.

For those who want to start dynamic web programming, but don't know what to choose among the many Python web frameworks, this program might be a good starting point

ScriptServer is a minimalist application server, handling both GET and POST requests, including multipart/form-data for file uploads, HTTP redirections, and with an in-memory session management. It can run Python scripts and template files using the standard string substitution format

The scripts are run in the same process as the server, avoiding the CGI overhead. The environment variables are provided in the namespace where the script runs

To start the server, run

python ScriptServer.py

In your web browser, enter http://localhost, this will show you a listing of the directory. Add the scripts in the same directory as ScriptServer

Simple HTTP server based on asyncore/asynchat (Python)

2005-10-16T08:26:59-07:00

Python recipe 259148 by Pierre Quentel (web). Revision 8.

A simple HTTP Server, intended to be as simple as the standard module SimpleHTTPServer, built upon the asyncore/asynchat modules (uses non-blocking sockets). Provides a Server (copied from medusa http_server) and a RequestHandler class. RequestHandler handles both GET and POST methods and inherits SimpleHTTPServer.SimpleHTTPRequestHandler

It can be easily extended by overriding the handle_data() method in the RequestHandler class

Non-blocking readlines() (Python)

2014-06-30T20:30:57-07:00

Python recipe 578900 by Zack Weinberg (concurrency, input, line, nonblocking).

A generator function which takes a file object (assumed to be some sort of pipe or socket, open for reading), and yields lines from it without blocking. If there is no input available, it will yield an endless stream of empty strings until input becomes available again; caller is responsible for not going into a busy loop. (Newlines are normalized but not stripped, so if there is actually a blank line in the input, the value yielded will be '\n'.) The intended use case is a thread which must respond promptly to input from a pipe, and also something else which cannot be fed to select (e.g. a queue.Queue). Note that the file object is ignored except for its fileno.

Only tested on Unix. Only tested on 3.4; ought to work with any python that has bytearray, locale.getpreferredencoding, and fcntl.

System Authentication against /etc/shadow or /etc/passwd (Python)

2013-03-11T12:40:10-07:00

Python recipe 578489 by James Mills (authentication, password, system).

Sometimes it's useful to perform System Authentication against a Local System using the /etc/shadow or /etc/passwd password databases. This recipe provides a simple function that does exactly that.

Sending Email in Python (Python)

2013-02-24T13:47:01-08:00

Python recipe 578472 by James Mills (email, email_sending, sendmail, smtp).

Every Python Application needs to send email at some point. Whether it's for reporting errors, status updates or simply the core functionality of the system this little recipe should help! Documented and Tested.

For AMIGA-Heads Only. Poking A HW, (Memory), Address On A Classic AMIGA, Inside Text Mode Python. (Python)

2012-09-09T19:25:00-07:00

Python recipe 578255 by Barry Walker (amiga, demo, e_uae, hardware, memory, poke, winuae).

For AMIGA-Heads Only...

This code is purely for a minimum of a stock Classic AMIGA A1200(HD), E-UAE, and WinUAE running AMIGA OS3.0x to 3.1x. It will NOT work on any other platform!

(It MIGHT work on AMIGA OS3.5x and 3.9x with Python 2.4.6, but totally untested and I hold no responsibility for the outcome when trying it.)

It is a DEMO to poke a byte inside _ANY_ memory address inside the standard CPU 68EC020 16MB boundary.

This is not a function nor a class but just a DEMO to show how to write directly to HW, (or memory), addresses.

POKING memory or hardware addresses is not recommended for novices without studying the machine first, and, this code will ignore any _ENFORCER_hits_.

I experimented with this several years ago and have decided to finally release it. I do await the flak!

It works from Python Versions 1.4.0 to 2.0.1 for the classic AMIGA.

This is issued as Public Domain and you may do with it as you please.

Ensure that the T: Volume exists on the running machine.

See inside the code and text below it also as to how it works...

Bazza, G0LCU...

Execute remote commands on windows like psexec (Python)

2011-11-18T11:54:42-08:00

Python recipe 577945 by Ofer Helman (command, remote, windows). Revision 4.

This code attempts to implement psexec in python code, using wmi. As part of a project of mine I had to run remote commands on remote Windows machines from other Windows machine. At first I used psexec for that with subprocess.Popen. The reason in this code for creating .bat files and running them remotely is because complicated commands do not run properly with Win32_Process.Create

In this code I used this code: http://code.activestate.com/recipes/442521/history/3/

required installations:

pywin32 - http://sourceforge.net/projects/pywin32/files/pywin32/Build216/

wmi - http://timgolden.me.uk/python/downloads/

Asynchronous subprocess using asyncore (Python)

2013-01-21T19:51:00-08:00

Python recipe 576957 by Glenn Eychaner (async, asynchronous, asyncore, coroutine, decorator, generator, ipc, subprocess). Revision 21.

A coroutine-based wrapper for subprocess.Popen that uses asyncore to communicate with child processes asynchronously. This allows subprocesses to be called from within socket servers or clients without needing a complicated event loop to check both. Uses recipe 576965 to provide the asynchronous coroutine framework, recipe 576967 to provide asynchronous pipes, and recipe 577600 to provide multiple alarms.