#!/usr/bin/env python

__author__="Andrew Pennebaker (andrew.pennebaker@gmail.com)"
__date__="10 Oct 2005 - 17 Jul 2006"
__copyright__="Copyright 2006 Andrew Pennebaker"
__license__="GPL"
__version__="0.4"
__credits__="From the PyPy project"
__URL__="http://snippets.dzone.com/posts/show/3540"

import HashFunction

class CRC32(HashFunction.HashFunction):
	BLOCK_SIZE=1
	DIGEST_SIZE=4

	INIT=0x00000000
	SUM_REQ="Sum >= 0"

	TEST_DATA="abc"
	TEST_HASH=0x352441c2

	TABLE=[
		0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
		0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
		0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
		0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
		0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
		0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
		0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
		0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
		0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
		0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
		0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
		0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
		0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
		0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
		0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
		0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
		0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
		0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
		0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
		0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
		0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
		0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
		0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
		0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
		0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
		0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
		0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
		0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
		0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
		0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
		0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
		0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
		0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
		0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
		0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
		0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
		0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
		0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
		0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
		0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
		0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
		0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
		0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
		0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
		0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
		0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
		0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
		0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
		0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
		0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
		0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
		0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
		0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
		0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
		0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
		0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
		0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
		0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
		0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
		0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
		0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
		0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
		0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
		0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
	]

	def __init__(self, sum=0x00000000):
		self.sum=sum^0xffffffff

	def sumValid(self, sum):
		return sum>=0

	def _update(self, b):
		self.sum=self.TABLE[(self.sum^b)&0xff]^(self.sum>>8)

	def digest(self):
		return self.sum^0xffffffff

	def format(self, data):
		return "%02x" % (data)

	def unformat(self, hash):
		return long(hash, 16)

if __name__=="__main__":
	HashFunction.main(CRC32)

"""Andrew's Input/Output module"""

__author__="Andrew Pennebaker (andrew.pennebaker@gmail.com)"
__date__="21 Dec 2005 - 22 Dec 2005"
__copyright__="Copyright 2005 Andrew Pennebaker"
__license__="GPL"
__version__="0.1"
__URL__="http://snippets.dzone.com/posts/show/3537"

def getByteArray(s):
	return [ord(e) for e in s]

def readAll(f):
	byteArray=[]
	line=f.readline()
	while line!="":
		for e in line:
			byteArray.append(ord(e))
		line=f.readline()

	return byteArray

def chomp(text):
	if text=="" or text=="\n":
		return ""
	elif text[-1]=="\n":
		return text[:-1]

	return text

#!/usr/bin/env python

"""A Brainfuck interpreter"""

__author__="Andrew Pennebaker (andrew.pennebaker@gmail.com)"
__date__="18 Nov 2005 - 27 Feb 2006"
__copyright__="Copyright 2006 Andrew Pennebaker"
__license__="GPL"
__version__="0.5"
__URL__="http://snippets.dzone.com/posts/show/3536"

from aio import chomp

import sys
from getopt import getopt

tape=[0]*100
address=0

def sublevel(toplevel):
	i=0

	# until a balanced-bracket code block is found, add a character

	while toplevel[0:i+1].count("[")!=toplevel[0:i+1].count("]"): i+=1

	return toplevel[1:i]

def run(instructions):
	global tape
	global address

	position=0
	while position<len(instructions):
		cmd=instructions[position]

		if cmd=="<": address-=1
		elif cmd==">": address+=1
		elif cmd=="+": tape[address]+=1
		elif cmd=="-": tape[address]-=1
		elif cmd==".": sys.stdout.write(chr(tape[address]))
		elif cmd==",":
			try: tape[address]=ord(sys.stdin.read(1))
			except: tape[address]=-1
		elif cmd=="[":
			level=sublevel(instructions[position:])
			while tape[address]!=0: run(level)

			position+=len(level)+1

		position+=1

def usage():
	print "Usage: %s [options] <sourcefile>" % (sys.argv[0])
	print "--help (usage)"

	sys.exit()

def main():
	systemArgs=sys.argv[1:] # ignore program name

	live=False

	optlist=[]
	args=[]

	try:
		optlist, args=getopt(systemArgs, None, ["help"])
	except Exception, e:
		usage()

	live=len(args)<1

	for option, value in optlist:
		if option=="--help":
			usage()

	if live:
		print "--BF Interpreter 0.5--"
		print "  Type exit to exit."

		line="not exit"
		while line!="exit":
			sys.stdout.write("% ")
			line=chomp(sys.stdin.readline())

			if line.count("[")!=line.count("]"):
				raise "Unbalanced brackets"
			else:
				run(line)
	else:
		src=args[0]

		srcfile=open(src, "r")
		code="".join(srcfile.readlines())
		srcfile.close()

		if code.count("[")!=code.count("]"):
			raise "Unbalanced brackets"
		else:
			run(code)

if __name__=="__main__":
	try:
		main()
	except KeyboardInterrupt, e:
		pass

#!/usr/bin/env python

__author__="Andrew Pennebaker (andrew.pennebaker@gmail.com)"
__date__="9 Dec 2006 - 10 Dec 2006"
__copyright__="Copyright 2006 Andrew Pennebaker"
__license__="GPL"
__version__="0.0.1"
__credits__="Based on Yubnub for Windows (http://www.opbarnes.com/blog/Programming/OPB/Utilities/yubnub.html)"
__URL__="http://snippets.dzone.com/posts/show/3120"

from html2txt import html2txt

import webbrowser
from urllib import urlopen
import re

import sys
from getopt import getopt

PARSER="http://yubnub.org/parser/parse?command="

BROWSER_MODE="BROWSER"
PLAIN_MODE="PLAIN"

def space2plus(s):
	return "+".join(s.split())

def yubnub(command=""):
	global PARSER

	return PARSER+space2plus(command)

def yubnubBrowser(command):
	return webbrowser.open(yubnub(command))

def cleanHTML(html):
	h=html2txt()
	h.feed(html)
	h.close()

	return h.output()

def yubnubPlain(command, clean=True):
	command=yubnub(command)

	try:
		url=urlopen(command)
		lines=url.readlines()
		url.close()

		lines="".join(lines)

		if clean:
			return cleanHTML(lines)

		return lines

	except IOError, e:
		return "Error connecting to "+command

def usage():
	print "Usage: "+sys.argv[0]+" [options] <command>"
	print "-b --browser"
	print "\n--plain (default)"
	print "\t-c --clean (default)"
	print "\t-d --dirty"
	print "\n--parser <parser> (experimental)"
	print "\n-h --help"

	sys.exit()

def main():
	global PARSER

	global BROWSER_MODE
	global PLAIN_MODE

	mode=PLAIN_MODE
	parser=PARSER
	clean=True

	systemArgs=sys.argv[1:]
	optlist, args=[], []
	try:
		optlist, args=getopt(systemArgs, "bhcd", ["browser", "plain", "clean", "dirty", "parser=", "help"])
	except:
		usage()

	for option, value in optlist:
		if option=="-h" or option=="--help":
			usage()

		elif option=="-b" or option=="--browser":
			mode=BROWSER_MODE
		elif option=="--plain":
			mode=PLAIN_MODE
		elif option=="-c" or option=="--clean":
			clean=True
		elif option=="-d" or option=="--dirty":
			clean=False
		elif option=="--parser":
			parser=value

	command=" ".join(args)

	if mode==BROWSER_MODE:
		yubnubBrowser(command)
	elif mode==PLAIN_MODE:
		for line in yubnubPlain(command, clean):
			sys.stdout.write(line)
		print ""

if __name__=="__main__":
	main()

__author__="Andrew Pennebaker (andrew.pennebaker@gmail.com)"
__date__="11 Jul 2006 - 24 Oct 2006"
__copyright__="Copyright 2006 Andrew Pennebaker"
__license__="GPL"
__URL__="http://snippets.dzone.com/posts/show/2890"

import time, os, socket

import downloader
from Adler32 import Adler32

PAGE_URL="http://www.mozilla.com"
SEARCH_STRING="irefox 2"
BROWSER="firefox"
MEDIA_PLAYER="winamp"
SONG="song 2.ogg"
SOFTWARE_URL="http://www.mozilla.com/products/download.html?product=firefox-2.0&os=win&lang=en-US"

def message(text=""):
	print "[%s] %s" % (time.asctime(), text)

def main():
	global PAGE_URL
	global SEARCH_STRING
	global BROWSER
	global MEDIA_PLAYER
	global SONG
	global SOFTWARE_URL

	hasUpdated=False
	includesFF2=False
	firstHash=None
	currentHash=firstHash

	hasher=Adler32()

	while (not hasUpdated) or (not includesFF2):
		time.sleep(1) # seconds

		try:
			message("checking page")

			down=downloader.createDownload(PAGE_URL)
			instream=down[0]
			outstream=open(os.getcwd()+os.sep+down[1], "wb")

			line=instream.readline()
			includesFF2=False
			while line!="":
				if SEARCH_STRING in line:
					includesFF2=True
				hasher.update(line)
				outstream.write(line)
				line=instream.readline()
			instream.close()
			outstream.close()

			if firstHash==None:
				currentHash=firstHash=hasher.formatDigest()
				message("first hash: "+firstHash)
			else:
				currentHash=hasher.formatDigest()

			hasher.reset()

			if not includesFF2:
				message("proxy page")
			else:
				hasUpdated=(firstHash!=currentHash)
				if not hasUpdated:
					message("static")
		except IOError, e:
			message("connection error")
		except Exception, e:
			message(e)

	message("detected update")
	message("alerting")

	os.popen("start "+BROWSER+" "+PAGE_URL)
	os.popen("start "+MEDIA_PLAYER+" \""+os.getcwd()+os.sep+SONG+"\"")

	message("alerted")
	message("downloading")

	try:
		down=downloader.createDownload(SOFTWARE_URL)
		instream=down[0]
		outstream=open(os.getcwd()+os.sep+down[1], "wb")
		downloader.download(instream, outstream)

		message("downloaded")
	except:
		message("could not download")

	message("done")

if __name__=="__main__":
	main()

__author__="Andrew Pennebaker (andrew.pennebaker@gmail.com)"
__date__="21 Dec 2005 - 17 Jul 2006"
__copyright__="Copyright 2006 Andrew Pennebaker"
__license__="GPL"
__version__="0.3"
__URL__="http://snippets.dzone.com/posts/show/2889"

import HashFunction

class Adler32(HashFunction.HashFunction):
	BLOCK_SIZE=1
	DIGEST_SIZE=2

	INIT=0x0001
	SUM_REQ="Sum >= 0"

	BASE=65521

	TEST_DATA="abc"
	TEST_HASH=0x24d0127

	def __init__(self, sum=0x0001):
		self.sum=sum

	def sumValid(self, sum):
		return sum>=0

	def _update(self, b):
		s1=self.sum&0xffff
		s2=(self.sum>>16)&0xffff

		s1=(s1+(b&0xff))%self.BASE
		s2=(s1+s2)%self.BASE

		self.sum=(s2<<16)|s1

	def digest(self):
		return self.sum

	def formatDigest(self):
		return "%02x" % (self.digest())

	def unformatDigest(self, hash):
		return int(hash, 16)

if __name__=="__main__":
	HashFunction.main(Adler32, "Adler32.py")

__author__="Andrew Pennebaker (andrew.pennebaker@gmail.com)"
__date__="21 Dec 2005 - 17 Jul 2006"
__copyright__="Copyright 2006 Andrew Pennebaker"
__license__="GPL"
__version__="0.3"
__URL__="http://snippets.dzone.com/posts/show/2888"

import sys
from getopt import getopt

TEST_MODE="TEST"
HASH_MODE="HASH"

class HashFunction:
	"""Base class for hash functions"""

	# bytes
	BLOCK_SIZE=1
	DIGEST_SIZE=1

	INIT=0x00
	SUM_REQ="Sum >= 0"

	TEST_DATA="abc"
	TEST_HASH=0x26

	def __init__(self, sum=0x00):
		"""Sets the context to some initial sum"""
		self.sum=sum&0xff

	def sumValid(self, sum):
		return sum>=0

	def _update(self, b):
		"""Data is an array of bytes"""

		self.sum=(self.sum+b)&0xff

	def update(self, data):
		"""Helper for _update(). Data is a string."""

		for byte in data:
			self._update(ord(byte))

	def digest(self):
		"""Returns an integer or long integer"""

		return self.sum

	def formatDigest(self):
		"""Returns a formatted string, different for each algorithm"""

		return "%02x" % (self.digest())

	def unformatDigest(self, hash):
		"""Converts formatted hash into integer"""

		return int(hash, 16)

	def reset(self):
		"""Reinitializes the hash"""

		self.__init__()

	def test(self):
		self.reset()
		self.update(self.TEST_DATA)
		hash=self.digest()
		formattedHash=self.formatDigest()
		unformattedHash=self.unformatDigest(formattedHash)

		if unformattedHash==self.TEST_HASH:
			return "OK"

		return [self.TEST_DATA, hash, formattedHash, unformattedHash, self.TEST_HASH]

def usage(script=sys.argv[0]):
	print "Usage: %s [options] <file1 file2 file3 ... >" % (script)
	print "\n-s --sum <sum>"
	print "-t --test engine"
	print "-h --help usage"

	sys.exit()

def main(hasher=HashFunction, script="HashFunction.py"):
	global TEST_MODE
	global HASH_MODE

	systemArgs=sys.argv[1:] # ignore program name

	mode=HASH_MODE
	sum=hasher.INIT

	optlist, args=[], []
	try:
		optlist, args=getopt(systemArgs, "s:th", ["sum=", "test", "help"])
	except Exception, e:
		usage(script)

	if len(optlist)<1 and len(args)<1:
		usage(script)

	for option, value in optlist:
		if option=="-h" or option=="--help":
			usage(script)
		elif option=="-t" or option=="--test":
			mode=TEST_MODE
		elif option=="-s" or option=="--sum":
			try:
				sum=hasher.unformatDigest(value)
				if not hasher.sumValid(sum):
					raise Exception
			except Exception, e:
				raise "Requires: %s" % (hasher.SUM_REQ)

	hasher=hasher()

	if mode==TEST_MODE:
		print hasher.test()
	elif mode==HASH_MODE:
		for file in args:
			f=None
			try:
				f=open(file, "rb")
			except Exception, e:
				print "Could not open %s" % (file)
			else:
				hasher.reset()
				for line in f:
					hasher.update(line)
				f.close()

				print hasher.formatDigest()

if __name__=="__main__":
	main(HashFunction, "HashFunction.py")

#!/usr/bin/env python

__author__="Andrew Pennebaker (andrew.pennebaker@gmail.com)"
__date__="3 Nov 2005 - 14 Feb 2007"
__copyright__="Copyright 2006 2007 Andrew Pennebaker"
__license__="GPL"
__version__="0.5"
__URL__="http://snippets.dzone.com/posts/show/2887"

from urllib import urlopen

import os

import sys
from getopt import getopt

def getURLName(url):
	directory=os.curdir

	name="%s%s%s" % (
		directory,
		os.sep,
		url.split("/")[-1]
	)

	return name

def createDownload(url, proxy=None):
	instream=urlopen(url, None, proxy)

	filename=instream.info().getheader("Content-Length")
	if filename==None:
		filename="temp"

	return (instream, filename)

def download(instream, outstream):
	outstream.write(instream.read())

	outstream.close()

def usage():
	print "Usage: %s [options] <url1 url2 url3 ...>" % (sys.argv[0])
	print "\n--httpproxy <proxy>"
	print "--ftpproxy <proxy>"
	print "--gopherproxy <proxy>"
	print "\n--help (usage)"

	sys.exit()

def main():
	systemArgs=sys.argv[1:] # ignore program name

	urls=[]
	proxies={}

	optlist=[]
	args=[]

	try:
		optlist, args=getopt(systemArgs, None, ["url=", "httpproxy=", "ftpproxy=", "gopherproxy=", "help"])
	except Exception, e:
		usage()

	if len(args)<1:
		usage()

	for option, value in optlist:
		if option=="--help":
			usage()

		elif option=="--httpproxy":
			proxies["http"]=value
		elif option=="--ftpproxy":
			proxies["ftp"]=value
		elif options=="--gopherproxy":
			proxies["gopher"]=value

	urls=args

	for url in urls:
		try:
			outfile=open(getURLName(url), "wb")
			fileName=outfile.name.split(os.sep)[-1]

			url, length=createDownload(url, proxies)
			if not length:
				length="?"

			print "Downloading %s (%s bytes) ..." % (url.url, length)
			if length!="?":
				length=float(length)
			bytesRead=0.0

			for line in url:
				bytesRead+=len(line)

				if length!="?":
					print "%s: %.02f/%.02f kb (%d%%)" % (
						fileName,
						bytesRead/1024.0,
						length/1024.0,
						100*bytesRead/length
					)

				outfile.write(line)

			url.close()
			outfile.close()
			print "Done"

		except Exception, e:
			print "Error downloading %s: %s" % (url, e)

if __name__=="__main__":
	main()