Archive for the ‘Programming’ Category.
This is always a fun project. The task? To create a random password of random length. The reason for a password generator obvious: you suck at choosing a password. Let's start with how to create the actual generator, and then we'll focus on the presentation.
from random import *
import string
# The characters to make up the random password
chars = string.ascii_letters + string.digits
def random_password():
""" Create a password of random length between 8 and 16
characters long, made up of numbers and letters.
"""
return "".join(choice(chars) for x in range(randint(8, 16)))The above function is pretty easy to follow. What it does is build a generator object that creates a random list of characters between 8 and 16 in length. It then just compresses the list into a string. You can do something as simple as print random_password() and it'll display a password in the terminal. This, of course, isn't really the best way of acheiving it. After all, you don't want to have to navigate the terminal each and every time. So, let's add in a graphical user interface using the Tkinter window builder:
from Tkinter import *
from random import *
import string
# The characters to make up the random password
chars = string.ascii_letters + string.digits
def random_password():
""" Create a password of random length between 8 and 16
characters long, made up of numbers and letters.
"""
return "".join(choice(chars) for x in range(randint(8, 16)))
#
# BEGIN GUI CODE
#
root = Tk()
root.title("Password Generator")
root.resizable(0,0)
root.minsize(300,0)
frame = Frame(root)
frame.pack(pady=10, padx=5)
content = StringVar()
updater = lambda:content.set(random_password())
gen_btn = Button(frame, text="Generate", command=updater)
gen_btn.config(font=("sans-serif", 14), bg="#92CC92")
gen_btn.pack(side=LEFT, padx=5)
field = Entry(frame, textvariable=content)
field.config(fg='blue', font=('courier', 16, "bold"), justify='center')
field.pack(fill=BOTH, side=RIGHT, padx=5)
root.mainloop()The above should be pretty simple to follow. As you can see, pressing the gen_btn activates the updater lambda function which populates the entry field. Here is a sample output:
Simple, clean, and easy. This is just a quick project I made for myself and decided to share it.
On this Friday the 13th, we are to witness a very unique moment in history. That is, it is the day when UNIX time will roll over to 1234567890. Here's a simple Python/Tk app that'll show the timestamp.
import time
from Tkinter import *
class TimestampClock(Frame):
def __init__(self, root):
Frame.__init__(self, root)
self.pack()
self.time = Label(self, text=int(time.time()))
self.time.config(fg='red', font=('Monospace', 20, 'bold'))
self.time.pack(padx=10, pady=10)
self.update()
def update(self):
self.time.config(text=int(time.time()))
self.after(1000, self.update)
if __name__ == "__main__":
root = Tk()
root.title("Timestamp-Clock")
root.wm_attributes("-topmost", 1)
root.resizable(0,0)
root.minsize(300,50)
TimestampClock(root).mainloop()I hope you did something special for the occasion. Me? I was sitting in a computer lab at Chemeketa waiting for the clock to hit that special number. Here is my screen grab of this great event:
A very large oddity regarding the newest version of Python is that the wsgiref module is completely broken. Go ahead and try to run the following:
from wsgiref.simple_server import make_server, demo_app
httpd = make_server('', 8000, demo_app)
httpd.handle_request()You should notice that a nice little "ValueError: need more than 1 value to unpack" message when you try to open it in your web browser. The main ticket for this bug can be found here, and it comes with a patch! If you're running Linux, then the fix is easy. Once you download it simply run this in the command line in the same folder as the patch to issue it:
sudo patch < wsgiref.patch
It will come up with prompts for each of the files to in wsgiref to patch. Simply specify their locations and you're done!
Update: Sources have told me that this has been fixed in Python 3.0.1, so here's hoping.
On occasion, one requires the need to lock a file. Now, this is relatively easy if you're targeting a specific platform because there is often a function in the library to do it for you. But what if you want to target a larger set of platforms? The following is a solution I wrote up today. It's lockfile creation is an atomic operation and thus doesn't suffer from any race conditions. It should work in both Windows and Unix environments.
import os
import time
import errno
class FileLockException(Exception):
pass
class FileLock(object):
""" A file locking mechanism that has context-manager support so
you can use it in a with statement. This should be relatively cross
compatible as it doesn't rely on msvcrt or fcntl for the locking.
"""
def __init__(self, file_name, timeout=10, delay=.05):
""" Prepare the file locker. Specify the file to lock and optionally
the maximum timeout and the delay between each attempt to lock.
"""
self.is_locked = False
self.lockfile = os.path.join(os.getcwd(), "%s.lock" % file_name)
self.file_name = file_name
self.timeout = timeout
self.delay = delay
def acquire(self):
""" Acquire the lock, if possible. If the lock is in use, it check again
every `wait` seconds. It does this until it either gets the lock or
exceeds `timeout` number of seconds, in which case it throws
an exception.
"""
start_time = time.time()
while True:
try:
self.fd = os.open(self.lockfile, os.O_CREAT|os.O_EXCL|os.O_RDWR)
break;
except OSError as e:
if e.errno != errno.EEXIST:
raise
if (time.time() - start_time) >= self.timeout:
raise FileLockException("Timeout occured.")
time.sleep(self.delay)
self.is_locked = True
def release(self):
""" Get rid of the lock by deleting the lockfile.
When working in a `with` statement, this gets automatically
called at the end.
"""
if self.is_locked:
os.close(self.fd)
os.unlink(self.lockfile)
self.is_locked = False
def __enter__(self):
""" Activated when used in the with statement.
Should automatically acquire a lock to be used in the with block.
"""
if not self.is_locked:
self.acquire()
return self
def __exit__(self, type, value, traceback):
""" Activated at the end of the with statement.
It automatically releases the lock if it isn't locked.
"""
if self.is_locked:
self.release()
def __del__(self):
""" Make sure that the FileLock instance doesn't leave a lockfile
lying around.
"""
self.release()The above class is best used in a context manager fashion through the with statement like in the example below:
with FileLock("test.txt", timeout=2) as lock:
print("Lock acquired.")
# Do something with the locked fileThe largest downside of this is that the directory the file is located in must be writable. I hope this code helps you. Of course, if you have a better recipe, please share it in the comments. ;)
As of Python 3.0, rot13 is no longer built accessible from the str.encode("rot13") call. If needed, here is an implementation I pieced together:
from string import ascii_uppercase, ascii_lowercase
def rot13(data):
""" A simple rot-13 encoder since `str.encode('rot13')` was removed from
Python as of version 3.0. It rotates both uppercase and lowercase letters individually.
"""
total = []
for char in data:
if char in ascii_uppercase:
index = (ascii_uppercase.find(char) + 13) % 26
total.append(ascii_uppercase[index])
elif char in ascii_lowercase:
index = (ascii_lowercase.find(char) + 13) % 26
total.append(ascii_lowercase[index])
else:
total.append(char)
return "".join(total)Pretty simple, right? Knowing how modulus (%) works helped greatly in finding the proper index. I hope this helps.
Update: There's a simpler solution on the comments below. You should probably use it instead.
I've just started learning Python WSGI (PEP-333) and thought the best way to learn would be to write some WSGI tools myself. Most recently, I chose to write a middleware application that converts all output into valid gzipped data. In this article, I will be demonstrating how my middleware gzipper works and how to implement it.
Continue reading 'Python WSGI Middleware for automatic Gzipping' »
I have put up a new script for those of you who are running Lighttpd. You can find it here. It is a dir-generator that is nearly identical to the default, but with the added bonus that you can sort by name, size, modification time, and file type. One downside is that it doesn't display mime type like the original does since to do that with PHP, it is required that an extension is insalled.
