--- /dev/null
+#
+# DSA.py : Stupid name. Should really be called qNEW.py or something.
+# Suggestions for a better name would be welcome.
+#
+# Maintained by A.M. Kuchling (amk@magnet.com)
+# Date: 1997/09/03
+#
+# Distribute and use freely; there are no restrictions on further
+# dissemination and usage except those imposed by the laws of your
+# country of residence.
+#
+
+# TODO :
+# Change the name
+# Add more comments and docstrings
+# Write documentation
+# Add better RNG (?)
+
+import types, md5
+
+error = 'DSA module error'
+
+def RandomNumber(N, randfunc):
+ "Get an N-bit random number"
+ str=randfunc(N/8)
+ char=ord(randfunc(1))>>(8-(N%8))
+ return Str2Int(chr(char)+str)
+
+def Int2Str(n):
+ "Convert an integer to a string form"
+ s=''
+ while n>0:
+ s=chr(n & 255)+s
+ n=n>>8
+ return s
+
+def Str2Int(s):
+ "Convert a string to a long integer"
+ if type(s)!=types.StringType: return s # Integers will be left alone
+ return reduce(lambda x,y : x*256+ord(y), s, 0L)
+
+
+def getPrime(N, randfunc):
+ "Find a prime number measuring N bits"
+ number=RandomNumber(N, randfunc) | 1
+ while (not isPrime(number)):
+ number=number+2
+ return number
+
+sieve=[2,3,5,7,11,13,17,19,23,29,31,37,41]
+def isPrime(N):
+ """Test if a number N is prime, using a simple sieve check,
+ followed by a more elaborate Rabin-Miller test."""
+ for i in sieve:
+ if (N % i)==0: return 0
+ N1=N - 1L ; n=1L
+ while (n<N): n=n<<1L # Compute number of bits in N
+ for j in sieve:
+ a=long(j) ; d=1L ; t=n
+ while (t): # Iterate over the bits in N1
+ x=(d*d) % N
+ if x==1L and d!=1L and d!=N1: return 0 # Square root of 1 found
+ if N1 & t: d=(x*a) % N
+ else: d=x
+ t=t>>1L
+ if d!=1L: return 0
+ return 1
+
+class DSAobj:
+ def size(self):
+ "Return the max. number of bits that can be handled by this key"
+ bits, power = 0,1L
+ while (power<self.p): bits, power = bits+1, power<<1
+ return bits-1
+
+ def hasprivate(self):
+ """Return a Boolean denoting whether the object contains private components"""
+ if hasattr(self, 'x'): return 1
+ else: return 0
+
+ def cansign(self):
+ return self.hasprivate()
+ def canencrypt(self):
+ return 0
+
+ def publickey(self):
+ new=DSAobj()
+ for i in 'pqgy': setattr(new, i, getattr(self, i))
+ return new
+
+ def _sign(self, M, K):
+ if (self.q<=K):
+ raise error, 'K is greater than q'
+ r=pow(self.g, K, self.p) % self.q
+ s=(K- (r*M*self.x % self.q)) % self.q
+ return (r,s)
+ def _verify(self, M, sig):
+ r, s = sig
+ if r<=0 or r>=self.q or s<=0 or s>=self.q: return 0
+ v1=pow(self.g, s, self.p)
+ v2=pow(self.y, M*r, self.p)
+ v=((v1*v2) % self.p)
+ v=v % self.q
+ if v==r: return 1
+ return 0
+
+ def sign(self, M, K):
+ if (not self.hasprivate()):
+ raise error, 'Private key not available in this object'
+ if type(M)==types.StringType: M=Str2Int(M)
+ if type(K)==types.StringType: K=Str2Int(K)
+ return self._sign(M, K)
+ def verify(self, M, signature):
+ if type(M)==types.StringType: M=Str2Int(M)
+ return self._verify(M, signature)
+ validate=verify
+
+ def generate(self, L, randfunc, progress_func=None):
+ """Generate a private key with L bits"""
+ HASHBITS=128 # Number of bits in the hashing algorithm used
+ # (128 for MD5; change to 160 for SHA)
+
+ if L<512: raise error, 'Key length <512 bits'
+ # Generate string S and prime q
+ if progress_func: apply(progress_func, ('p,q\n',))
+ while (1):
+ self.q = getPrime(160, randfunc)
+ S = Int2Str(self.q)
+ n=(L-1)/HASHBITS
+ C, N, V = 0, 2, {}
+# b=(self.q >> 5) & 15
+ b= (L-1) % HASHBITS
+ powb=pow(long(2), b)
+ powL1=pow(long(2), L-1)
+ while C<4096:
+ for k in range(0, n+1):
+ V[k]=Str2Int(md5.new(S+str(N)+str(k)).digest())
+ W=V[n] % powb
+ for k in range(n-1, -1, -1):
+ W=(W<< long(HASHBITS) )+V[k]
+ X=W+powL1
+ p=X-(X%(2*self.q)-1)
+ if powL1<=p and isPrime(p): break
+ C, N = C+1, N+n+1
+ if C<4096: break
+ if progress_func: apply(progress_func, ('4096 multiples failed\n',) )
+ self.p = p
+ power=(p-1)/self.q
+ if progress_func: apply(progress_func, ('h,g\n',))
+ while (1):
+ h=Str2Int(randfunc(L)) % (p-1)
+ g=pow(h, power, p)
+ if 1<h<p-1 and g>1: break
+ self.g=g
+ if progress_func: apply(progress_func, ('x,y\n',))
+ while (1):
+ x=Str2Int(randfunc(20))
+ if 0<x<self.q: break
+ self.x, self.y=x, pow(g, x, p)
+ return self
+
+object=DSAobj
+
+# XXX this random number generation function sucks, since it isn't
+# cryptographically strong! But it'll do for this first release...
+
+def randfunc(N):
+ import os, string
+ if string.lower(os.uname()[0])=='linux':
+ # On Linux, use /dev/urandom
+ f=open('/dev/urandom', 'r')
+ return f.read(N)
+ else:
+ import time
+ s=""
+ while len(s)<N:
+ rand=md5.new(str(time.time())).digest()
+ s=s+rand
+ return s[0:N]
+
+if __name__=='__main__':
+ import sys, string
+ BITS=512
+ if len(sys.argv)>1:
+ BITS=string.atoi(sys.argv[1])
+ print ' Generating', BITS, 'bit key'
+ key=DSAobj()
+ key.generate(BITS, randfunc, sys.stdout.write)
+ print ' Key data: (the private key is x)'
+ for i in 'xygqp': print '\t', i, ':', hex(getattr(key, i))
+ plaintext="Hello"
+
+ if key.cansign():
+ print ' Signature test'
+ print "Plaintext:", plaintext
+ K=getPrime(30, randfunc)
+ signature=key.sign(plaintext, K)
+ print "Signature:", signature
+ result=key.verify(plaintext, signature)
+ if not result:
+ print " Sig. verification failed when it should have succeeded"
+ else: print 'Signature verified'
+
+ # Test on a mangled plaintext
+ result=key.verify(plaintext[:-1], signature)
+ if result:
+ print " Sig. verification succeeded when it should have failed"
+
+ # Change a single bit in the plaintext
+ badtext=plaintext[:-3]+chr( 1 ^ ord(plaintext[-3]) )+plaintext[-3:]
+ result=key.verify(badtext, signature)
+ if result:
+ print " Sig. verification succeeded when it should have failed"
+
+ print 'Removing private key data'
+ pubonly=key.publickey()
+ result=pubonly.verify(plaintext, signature)
+ if not result:
+ print " Sig. verification failed when it should have succeeded"
+ else:
+ print 'Signature verified'
--- /dev/null
+"""Class based built-in exception hierarchy.
+
+This is a new feature whereby all the standard built-in exceptions,
+traditionally string objects, are replaced with classes. This gives
+Python's exception handling mechanism a more object-oriented feel.
+
+Most existing code should continue to work with class based
+exceptions. Some tricky uses of IOError may break, but the most
+common uses should work.
+
+To disable this feature, start the Python executable with the -X option.
+
+Here is a rundown of the class hierarchy. You can change this by
+editing this file, but it isn't recommended. The classes with a `*'
+are new with this feature. They are defined as tuples containing the
+derived exceptions when string-based exceptions are used.
+
+Exception(*)
+ |
+ +-- StandardError(*)
+ |
+ +-- SystemExit
+ +-- KeyboardInterrupt
+ +-- ImportError
+ +-- IOError
+ +-- EOFError
+ +-- RuntimeError
+ +-- NameError
+ +-- AttributeError
+ +-- SyntaxError
+ +-- TypeError
+ +-- AssertionError
+ +-- LookupError(*)
+ | |
+ | +-- IndexError
+ | +-- KeyError
+ |
+ +-- ArithmeticError(*)
+ | |
+ | +-- OverflowError
+ | +-- ZeroDivisionError
+ | +-- FloatingPointError
+ |
+ +-- ValueError
+ +-- SystemError
+ +-- MemoryError
+"""
+
+class Exception:
+ def __init__(self, *args):
+ self.args = args
+
+ def __str__(self):
+ if not self.args:
+ return ''
+ elif len(self.args) == 1:
+ return str(self.args[0])
+ else:
+ return str(self.args)
+
+ def __getitem__(self, i):
+ return self.args[i]
+
+class StandardError(Exception):
+ pass
+
+class SyntaxError(StandardError):
+ filename = lineno = offset = text = None
+ msg = ""
+ def __init__(self, *args):
+ self.args = args
+ if len(self.args) >= 1:
+ self.msg = self.args[0]
+ if len(self.args) == 2:
+ info = self.args[1]
+ try:
+ self.filename, self.lineno, self.offset, self.text = info
+ except:
+ pass
+ def __str__(self):
+ return str(self.msg)
+
+class IOError(StandardError):
+ def __init__(self, *args):
+ self.args = args
+ self.errno = None
+ self.strerror = None
+ if len(args) == 2:
+ # common case: PyErr_SetFromErrno()
+ self.errno = args[0]
+ self.strerror = args[1]
+
+class RuntimeError(StandardError):
+ pass
+
+class SystemError(StandardError):
+ pass
+
+class EOFError(StandardError):
+ pass
+
+class ImportError(StandardError):
+ pass
+
+class TypeError(StandardError):
+ pass
+
+class ValueError(StandardError):
+ pass
+
+class KeyboardInterrupt(StandardError):
+ pass
+
+class AssertionError(StandardError):
+ pass
+
+class ArithmeticError(StandardError):
+ pass
+
+class OverflowError(ArithmeticError):
+ pass
+
+class FloatingPointError(ArithmeticError):
+ pass
+
+class ZeroDivisionError(ArithmeticError):
+ pass
+
+class LookupError(StandardError):
+ pass
+
+class IndexError(LookupError):
+ pass
+
+class KeyError(LookupError):
+ pass
+
+class AttributeError(StandardError):
+ pass
+
+class NameError(StandardError):
+ pass
+
+class MemoryError(StandardError):
+ pass
+
+class SystemExit(Exception):
+ def __init__(self, *args):
+ self.args = args
+ if len(args) == 0:
+ self.code = None
+ elif len(args) == 1:
+ self.code = args[0]
+ else:
+ self.code = args
--- /dev/null
+"""Guess the MIME type of a file.
+
+This module defines one useful function:
+
+guess_type(url) -- guess the MIME type and encoding of a URL.
+
+It also contains the following, for tuning the behavior:
+
+Data:
+
+knownfiles -- list of files to parse
+inited -- flag set when init() has been called
+suffixes_map -- dictionary mapping suffixes to suffixes
+encodings_map -- dictionary mapping suffixes to encodings
+types_map -- dictionary mapping suffixes to types
+
+Functions:
+
+init([files]) -- parse a list of files, default knownfiles
+read_mime_types(file) -- parse one file, return a dictionary or None
+
+"""
+
+import string
+import posixpath
+
+knownfiles = [
+ "/usr/local/etc/httpd/conf/mime.types",
+ "/usr/local/lib/netscape/mime.types",
+ ]
+
+inited = 0
+
+def guess_type(url):
+ """Guess the type of a file based on its URL.
+
+ Return value is a tuple (type, encoding) where type is None if the
+ type can't be guessed (no or unknown suffix) or a string of the
+ form type/subtype, usable for a MIME Content-type header; and
+ encoding is None for no encoding or the name of the program used
+ to encode (e.g. compress or gzip). The mappings are table
+ driven. Encoding suffixes are case sensitive; type suffixes are
+ first tried case sensitive, then case insensitive.
+
+ The suffixes .tgz, .taz and .tz (case sensitive!) are all mapped
+ to ".tar.gz". (This is table-driven too, using the dictionary
+ suffixes_map).
+
+ """
+ if not inited:
+ init()
+ base, ext = posixpath.splitext(url)
+ while suffix_map.has_key(ext):
+ base, ext = posixpath.splitext(base + suffix_map[ext])
+ if encodings_map.has_key(ext):
+ encoding = encodings_map[ext]
+ base, ext = posixpath.splitext(base)
+ else:
+ encoding = None
+ if types_map.has_key(ext):
+ return types_map[ext], encoding
+ elif types_map.has_key(string.lower(ext)):
+ return types_map[string.lower(ext)], encoding
+ else:
+ return None, encoding
+
+def init(files=None):
+ global inited
+ for file in files or knownfiles:
+ s = read_mime_types(file)
+ if s:
+ for key, value in s.items():
+ types_map[key] = value
+ inited = 1
+
+def read_mime_types(file):
+ try:
+ f = open(file)
+ except IOError:
+ return None
+ map = {}
+ while 1:
+ line = f.readline()
+ if not line: break
+ words = string.split(line)
+ for i in range(len(words)):
+ if words[i][0] == '#':
+ del words[i:]
+ break
+ if not words: continue
+ type, suffixes = words[0], words[1:]
+ for suff in suffixes:
+ map['.'+suff] = type
+ f.close()
+ return map
+
+suffix_map = {
+ '.tgz': '.tar.gz',
+ '.taz': '.tar.gz',
+ '.tz': '.tar.gz',
+}
+
+encodings_map = {
+ '.gz': 'gzip',
+ '.Z': 'compress',
+ }
+
+types_map = {
+ '.a': 'application/octet-stream',
+ '.ai': 'application/postscript',
+ '.aif': 'audio/x-aiff',
+ '.aifc': 'audio/x-aiff',
+ '.aiff': 'audio/x-aiff',
+ '.au': 'audio/basic',
+ '.avi': 'video/x-msvideo',
+ '.bcpio': 'application/x-bcpio',
+ '.bin': 'application/octet-stream',
+ '.cdf': 'application/x-netcdf',
+ '.cpio': 'application/x-cpio',
+ '.csh': 'application/x-csh',
+ '.dll': 'application/octet-stream',
+ '.dvi': 'application/x-dvi',
+ '.exe': 'application/octet-stream',
+ '.eps': 'application/postscript',
+ '.etx': 'text/x-setext',
+ '.gif': 'image/gif',
+ '.gtar': 'application/x-gtar',
+ '.hdf': 'application/x-hdf',
+ '.htm': 'text/html',
+ '.html': 'text/html',
+ '.ief': 'image/ief',
+ '.jpe': 'image/jpeg',
+ '.jpeg': 'image/jpeg',
+ '.jpg': 'image/jpeg',
+ '.latex': 'application/x-latex',
+ '.man': 'application/x-troff-man',
+ '.me': 'application/x-troff-me',
+ '.mif': 'application/x-mif',
+ '.mov': 'video/quicktime',
+ '.movie': 'video/x-sgi-movie',
+ '.mpe': 'video/mpeg',
+ '.mpeg': 'video/mpeg',
+ '.mpg': 'video/mpeg',
+ '.ms': 'application/x-troff-ms',
+ '.nc': 'application/x-netcdf',
+ '.o': 'application/octet-stream',
+ '.obj': 'application/octet-stream',
+ '.oda': 'application/oda',
+ '.pbm': 'image/x-portable-bitmap',
+ '.pdf': 'application/pdf',
+ '.pgm': 'image/x-portable-graymap',
+ '.pnm': 'image/x-portable-anymap',
+ '.png': 'image/png',
+ '.ppm': 'image/x-portable-pixmap',
+ '.py': 'text/x-python',
+ '.pyc': 'application/x-python-code',
+ '.ps': 'application/postscript',
+ '.qt': 'video/quicktime',
+ '.ras': 'image/x-cmu-raster',
+ '.rgb': 'image/x-rgb',
+ '.roff': 'application/x-troff',
+ '.rtf': 'application/rtf',
+ '.rtx': 'text/richtext',
+ '.sgm': 'text/x-sgml',
+ '.sgml': 'text/x-sgml',
+ '.sh': 'application/x-sh',
+ '.shar': 'application/x-shar',
+ '.snd': 'audio/basic',
+ '.so': 'application/octet-stream',
+ '.src': 'application/x-wais-source',
+ '.sv4cpio': 'application/x-sv4cpio',
+ '.sv4crc': 'application/x-sv4crc',
+ '.t': 'application/x-troff',
+ '.tar': 'application/x-tar',
+ '.tcl': 'application/x-tcl',
+ '.tex': 'application/x-tex',
+ '.texi': 'application/x-texinfo',
+ '.texinfo': 'application/x-texinfo',
+ '.tif': 'image/tiff',
+ '.tiff': 'image/tiff',
+ '.tr': 'application/x-troff',
+ '.tsv': 'text/tab-separated-values',
+ '.txt': 'text/plain',
+ '.ustar': 'application/x-ustar',
+ '.wav': 'audio/x-wav',
+ '.xbm': 'image/x-xbitmap',
+ '.xpm': 'image/x-xpixmap',
+ '.xwd': 'image/x-xwindowdump',
+ '.zip': 'application/zip',
+ }
--- /dev/null
+"""Word completion for GNU readline 2.0.
+
+This requires the latest extension to the readline module (the
+set_completer() function). When completing a simple identifier, it
+completes keywords, built-ins and globals in __main__; when completing
+NAME.NAME..., it evaluates (!) the expression up to the last dot and
+completes its attributes.
+
+It's very cool to do "import string" type "string.", hit the
+completion key (twice), and see the list of names defined by the
+string module!
+
+Tip: to use the tab key as the completion key, call
+
+ readline.parse_and_bind("tab: complete")
+
+Notes:
+
+- Exceptions raised by the completer function are *ignored* (and
+generally cause the completion to fail). This is a feature -- since
+readline sets the tty device in raw (or cbreak) mode, printing a
+traceback wouldn't work well without some complicated hoopla to save,
+reset and restore the tty state.
+
+- The evaluation of the NAME.NAME... form may cause arbitrary
+application defined code to be executed if an object with a
+__getattr__ hook is found. Since it is the responsibility of the
+application (or the user) to enable this feature, I consider this an
+acceptable risk. More complicated expressions (e.g. function calls or
+indexing operations) are *not* evaluated.
+
+- GNU readline is also used by the built-in functions input() and
+raw_input(), and thus these also benefit/suffer from the completer
+features. Clearly an interactive application can benefit by
+specifying its own completer function and using raw_input() for all
+its input.
+
+- When the original stdin is not a tty device, GNU readline is never
+used, and this module (and the readline module) are silently inactive.
+
+"""
+
+import readline
+import keyword
+import __builtin__
+import __main__
+import string
+import re
+import traceback
+
+class Completer:
+
+ def complete(self, text, state):
+ """Return the next possible completion for 'text'.
+
+ This is called successively with state == 0, 1, 2, ... until it
+ returns None. The completion should begin with 'text'.
+
+ """
+ if state == 0:
+ if "." in text:
+ self.matches = self.attr_matches(text)
+ else:
+ self.matches = self.global_matches(text)
+ return self.matches[state]
+
+ def global_matches(self, text):
+ """Compute matches when text is a simple name.
+
+ Return a list of all keywords, built-in functions and names
+ currently defines in __main__ that match.
+
+ """
+ matches = []
+ n = len(text)
+ for list in [keyword.kwlist,
+ __builtin__.__dict__.keys(),
+ __main__.__dict__.keys()]:
+ for word in list:
+ if word[:n] == text:
+ matches.append(word)
+ return matches
+
+ def attr_matches(self, text):
+ """Compute matches when text contains a dot.
+
+ Assuming the text is of the form NAME.NAME....[NAME], and is
+ evaluabable in the globals of __main__, it will be evaluated
+ and its attributes (as revealed by dir()) are used as possible
+ completions.
+
+ WARNING: this can still invoke arbitrary C code, if an object
+ with a __getattr__ hook is evaluated.
+
+ """
+ m = re.match(r"(\w+(\.\w+)*)\.(\w*)", text)
+ if not m:
+ return
+ expr, attr = m.group(1, 3)
+ words = dir(eval(expr, __main__.__dict__))
+ matches = []
+ n = len(attr)
+ for word in words:
+ if word[:n] == attr:
+ matches.append("%s.%s" % (expr, word))
+ return matches
+
+readline.set_completer(Completer().complete)
--- /dev/null
+import sys
+sys.modules['ni'] = sys.modules[__name__]
The default is to print a traceback and continue.
"""
- exc, value, tb = sys.exc_type, sys.exc_value, sys.exc_traceback
print '-'*40
print 'Exception happened during processing of request from',
print client_address
import traceback
- traceback.print_exception(exc, value, tb)
+ traceback.print_exc()
print '-'*40
# Python test set -- part 5, built-in exceptions
from test_support import *
+from types import ClassType
print '5. Built-in exceptions'
# XXX This is not really enough, each *operation* should be tested!
-def r(name): print name
+def r(thing):
+ if type(thing) == ClassType:
+ print thing.__name__
+ else:
+ print thing
r(AttributeError)
import sys
""" return a more qualified path to name"""
import sys
import os
- for dir in sys.path:
+ path = sys.path
+ try:
+ path = [os.path.dirname(__file__)] + path
+ except NameError:
+ pass
+ for dir in path:
fullname = os.path.join(dir, name)
if os.path.exists(fullname):
return fullname
class AClass: pass
class BClass(AClass): pass
class CClass: pass
+class DClass(AClass):
+ def __init__(self, ignore):
+ pass
try: raise AClass()
except: pass
b = BClass()
try: raise AClass, b
-except BClass, v: raise TestFailed
-except AClass, v:
+except BClass, v:
if v != b: raise TestFailed
-
+else: raise TestFailed
try: raise b
except AClass, v:
if v != b: raise TestFailed
+# not enough arguments
try: raise BClass, a
except TypeError: pass
+try: raise DClass, a
+except DClass, v:
+ if not isinstance(v, DClass):
+ raise TestFailed
print '2.3 comparing function objects'
def findfile(file):
if os.path.isabs(file): return file
import sys
- for dn in sys.path:
+ path = sys.path
+ try:
+ path = [os.path.dirname(__file__)] + path
+ except NameError:
+ pass
+ for dn in path:
fn = os.path.join(dn, file)
if os.path.exists(fn): return fn
return file
a = r.encrypt(A)
print `a`
b = r.encryptmore(B)
-print b
+print `b`
A1 = r.decrypt(a)
print A1
except AttributeError:
pass
-print socket.error
+try: raise socket.error
+except socket.error: print "socket.error"
socket.AF_INET
for directive in ('a', 'A', 'b', 'B', 'c', 'd', 'H', 'I',
'j', 'm', 'M', 'p', 'S',
'U', 'w', 'W', 'x', 'X', 'y', 'Y', 'Z', '%'):
- format = '%' + directive
- time.strftime(format, tt)
+ format = ' %' + directive
+ try:
+ time.strftime(format, tt)
+ except ValueError:
+ print 'conversion specifier:', format, ' failed.'
time.timezone
time.tzname
--- /dev/null
+from test_support import *
+
+t = (1, 2, 3)
+l = [4, 5, 6]
+
+class Seq:
+ def __getitem__(self, i):
+ if i >= 0 and i < 3: return i
+ raise IndexError
+
+a = -1
+b = -1
+c = -1
+
+# unpack tuple
+if verbose:
+ print 'unpack tuple'
+a, b, c = t
+if a <> 1 or b <> 2 or c <> 3:
+ raise TestFailed
+
+# unpack list
+if verbose:
+ print 'unpack list'
+a, b, c = l
+if a <> 4 or b <> 5 or c <> 6:
+ raise TestFailed
+
+# unpack implied tuple
+if verbose:
+ print 'unpack implied tuple'
+a, b, c = 7, 8, 9
+if a <> 7 or b <> 8 or c <> 9:
+ raise TestFailed
+
+# unpack string... fun!
+if verbose:
+ print 'unpack string'
+a, b, c = 'one'
+if a <> 'o' or b <> 'n' or c <> 'e':
+ raise TestFailed
+
+# unpack generic sequence
+if verbose:
+ print 'unpack sequence'
+a, b, c = Seq()
+if a <> 0 or b <> 1 or c <> 2:
+ raise TestFailed
+
+# now for some failures
+
+# unpacking non-sequence
+if verbose:
+ print 'unpack non-sequence'
+try:
+ a, b, c = 7
+ raise TestFailed
+except TypeError:
+ pass
+
+
+# unpacking tuple of wrong size
+if verbose:
+ print 'unpack tuple wrong size'
+try:
+ a, b = t
+ raise TestFailed
+except ValueError:
+ pass
+
+# unpacking list of wrong size
+if verbose:
+ print 'unpack list wrong size'
+try:
+ a, b = l
+ raise TestFailed
+except ValueError:
+ pass
+
+
+# unpacking sequence too short
+if verbose:
+ print 'unpack sequence too short'
+try:
+ a, b, c, d = Seq()
+ raise TestFailed
+except ValueError:
+ pass
+
+
+# unpacking sequence too long
+if verbose:
+ print 'unpack sequence too long'
+try:
+ a, b = Seq()
+ raise TestFailed
+except ValueError:
+ pass
+
+
+# unpacking a sequence where the test for too long raises a different
+# kind of error
+BozoError = 'BozoError'
+
+class BadSeq:
+ def __getitem__(self, i):
+ if i >= 0 and i < 3:
+ return i
+ elif i == 3:
+ raise BozoError
+ else:
+ raise IndexError
+
+
+# trigger code while not expecting an IndexError
+if verbose:
+ print 'unpack sequence too long, wrong error'
+try:
+ a, b, c, d, e = BadSeq()
+ raise TestFailed
+except BozoError:
+ pass
+
+# trigger code while expecting an IndexError
+if verbose:
+ print 'unpack sequence too short, wrong error'
+try:
+ a, b, c = BadSeq()
+ raise TestFailed
+except BozoError:
+ pass
--- /dev/null
+import zlib
+import sys
+import imp
+import string
+
+t = imp.find_module('test_zlib')
+file = t[0]
+buf = file.read() * 8
+file.close()
+
+# test the chucksums
+print zlib.crc32('penguin'), zlib.crc32('penguin', 1)
+print zlib.adler32('penguin'), zlib.adler32('penguin', 1)
+
+# make sure we generate some expected errors
+try:
+ zlib.compress('ERROR', zlib.MAX_WBITS + 1)
+except zlib.error, msg:
+ print "expecting", msg
+try:
+ zlib.compressobj(1, 8, 0)
+except ValueError, msg:
+ print "expecting", msg
+try:
+ zlib.decompressobj(0)
+except ValueError, msg:
+ print "expecting", msg
+
+x = zlib.compress(buf)
+y = zlib.decompress(x)
+if buf != y:
+ print "normal compression/decompression failed"
+else:
+ print "normal compression/decompression succeeded"
+
+buf = buf * 16
+
+co = zlib.compressobj(8, 8, -15)
+x1 = co.compress(buf)
+x2 = co.flush()
+x = x1 + x2
+
+dc = zlib.decompressobj(-15)
+y1 = dc.decompress(x)
+y2 = dc.flush()
+y = y1 + y2
+if buf != y:
+ print "compress/decompression obj failed"
+else:
+ print "compress/decompression obj succeeded"
+
+co = zlib.compressobj(2, 8, -12, 9, 1)
+bufs = []
+for i in range(0, len(buf), 256):
+ bufs.append(co.compress(buf[i:i+256]))
+bufs.append(co.flush())
+combuf = string.join(bufs, '')
+
+decomp1 = zlib.decompress(combuf, -12, -5)
+if decomp1 != buf:
+ print "decompress with init options failed"
+else:
+ print "decompress with init options succeeded"
+
+deco = zlib.decompressobj(-12)
+bufs = []
+for i in range(0, len(combuf), 128):
+ bufs.append(deco.decompress(combuf[i:i+128]))
+bufs.append(deco.flush())
+decomp2 = string.join(buf, '')
+if decomp2 != buf:
+ print "decompressobj with init options failed"
+else:
+ print "decompressobj with init options succeeded"
+
+def ignore():
+ """An empty function with a big string.
+
+ Make the compression algorithm work a little harder.
+ """
+
+ """
+LAERTES
+
+ O, fear me not.
+ I stay too long: but here my father comes.
+
+ Enter POLONIUS
+
+ A double blessing is a double grace,
+ Occasion smiles upon a second leave.
+
+LORD POLONIUS
+
+ Yet here, Laertes! aboard, aboard, for shame!
+ The wind sits in the shoulder of your sail,
+ And you are stay'd for. There; my blessing with thee!
+ And these few precepts in thy memory
+ See thou character. Give thy thoughts no tongue,
+ Nor any unproportioned thought his act.
+ Be thou familiar, but by no means vulgar.
+ Those friends thou hast, and their adoption tried,
+ Grapple them to thy soul with hoops of steel;
+ But do not dull thy palm with entertainment
+ Of each new-hatch'd, unfledged comrade. Beware
+ Of entrance to a quarrel, but being in,
+ Bear't that the opposed may beware of thee.
+ Give every man thy ear, but few thy voice;
+ Take each man's censure, but reserve thy judgment.
+ Costly thy habit as thy purse can buy,
+ But not express'd in fancy; rich, not gaudy;
+ For the apparel oft proclaims the man,
+ And they in France of the best rank and station
+ Are of a most select and generous chief in that.
+ Neither a borrower nor a lender be;
+ For loan oft loses both itself and friend,
+ And borrowing dulls the edge of husbandry.
+ This above all: to thine ownself be true,
+ And it must follow, as the night the day,
+ Thou canst not then be false to any man.
+ Farewell: my blessing season this in thee!
+
+LAERTES
+
+ Most humbly do I take my leave, my lord.
+
+LORD POLONIUS
+
+ The time invites you; go; your servants tend.
+
+LAERTES
+
+ Farewell, Ophelia; and remember well
+ What I have said to you.
+
+OPHELIA
+
+ 'Tis in my memory lock'd,
+ And you yourself shall keep the key of it.
+
+LAERTES
+
+ Farewell.
+"""
+
n = 0
while tb is not None and (limit is None or n < limit):
f = tb.tb_frame
- lineno = tb.tb_lineno
+ lineno = tb_lineno(tb)
co = f.f_code
filename = co.co_filename
name = co.co_name
n = 0
while tb is not None and (limit is None or n < limit):
f = tb.tb_frame
- lineno = tb.tb_lineno
+ lineno = tb_lineno(tb)
co = f.f_code
filename = co.co_filename
name = co.co_name
list = []
n = 0
while f is not None and (limit is None or n < limit):
- lineno = f.f_lineno
+ lineno = f.f_lineno # XXX Too bad if -O is used
co = f.f_code
filename = co.co_filename
name = co.co_name
n = n+1
list.reverse()
return list
+
+# Calculate the correct line number of the traceback given in tb (even
+# with -O on).
+# Coded by Marc-Andre Lemburg from the example of PyCode_Addr2Line()
+# in compile.c.
+
+def tb_lineno(tb):
+ c = tb.tb_frame.f_code
+ tab = c.co_lnotab
+ line = c.co_firstlineno
+ stopat = tb.tb_lasti
+ addr = 0
+ for i in range(0, len(tab), 2):
+ addr = addr + ord(tab[i])
+ if addr > stopat:
+ break
+ line = line + ord(tab[i+1])
+ return line
-# This module contains several routines that help recognizing sound
-# files.
-#
-# Function whathdr() recognizes various types of sound file headers.
-# It understands almost all headers that SOX can decode.
-#
-# The return tuple contains the following items, in this order:
-# - file type (as SOX understands it)
-# - sampling rate (0 if unknown or hard to decode)
-# - number of channels (0 if unknown or hard to decode)
-# - number of frames in the file (-1 if unknown or hard to decode)
-# - number of bits/sample, or 'U' for U-LAW, or 'A' for A-LAW
-#
-# If the file doesn't have a recognizable type, it returns None.
-# If the file can't be opened, IOError is raised.
-#
-# To compute the total time, divide the number of frames by the
-# sampling rate (a frame contains a sample for each channel).
-#
-# Function whatraw() calls the "whatsound" program and interprets its
-# output. You'll have to guess the sampling rate by listening though!
-#
-# Function what() calls whathdr() and if it doesn't recognize the file
-# then calls whatraw().
-#
-# Finally, the function test() is a simple main program that calls
-# what() for all files mentioned on the argument list. For directory
-# arguments it calls what() for all files in that directory. Default
-# argument is "." (testing all files in the current directory). The
-# option -r tells it to recurse down directories found inside
-# explicitly given directories.
-#
-# The file structure is top-down except that the test program and its
-# subroutine come last.
-
-
-#------------------------------------------------------#
-# Guess the type of any sound file, raw or with header #
-#------------------------------------------------------#
-
-def what(filename):
- res = whathdr(filename)
- if not res:
- res = whatraw(filename)
- return res
-
-
-#-----------------------------#
-# Guess the type of raw sound #
-#-----------------------------#
-
-def whatraw(filename):
- # Assume it's always 1 channel, byte-sized samples
- # Don't assume anything about the rate
- import os
- from stat import ST_SIZE
- # XXX "whatsound" should be part of the distribution somehow...
- cmd = 'whatsound ' + filename + ' 2>/dev/null'
- cmd = 'PATH=$PATH:/ufs/guido/bin/sgi\n' + cmd
- pipe = os.popen(cmd, 'r')
- data = pipe.read()
- sts = pipe.close()
- if sts:
- return None
- if data[:13] == '-t raw -b -s ':
- type = 'sb'
- sample_size = 8
- elif data[:13] == '-t raw -b -u ':
- type = 'ub'
- sample_size = 8
- elif data[:13] == '-t raw -b -U ':
- type = 'ul'
- sample_size = 'U'
- else:
- return None
- try:
- frame_count = os.stat(filename)[ST_SIZE]
- except IOError:
- frame_count = -1
- return type, 0, 1, frame_count, sample_size
-
-
-#-------------------------#
-# Recognize sound headers #
-#-------------------------#
-
-def whathdr(filename):
- f = open(filename, 'r')
- h = f.read(512)
- for tf in tests:
- res = tf(h, f)
- if res:
- return res
- return None
-
-
-#-----------------------------------#
-# Subroutines per sound header type #
-#-----------------------------------#
-
-tests = []
-
-def test_aifc(h, f):
- import aifc
- if h[:4] <> 'FORM':
- return None
- if h[8:12] == 'AIFC':
- fmt = 'aifc'
- elif h[8:12] == 'AIFF':
- fmt = 'aiff'
- else:
- return None
- f.seek(0)
- try:
- a = aifc.openfp(f, 'r')
- except (EOFError, aifc.Error):
- return None
- return (fmt, a.getframerate(), a.getnchannels(), \
- a.getnframes(), 8*a.getsampwidth())
-
-tests.append(test_aifc)
-
-
-def test_au(h, f):
- if h[:4] == '.snd':
- f = get_long_be
- elif h[:4] in ('\0ds.', 'dns.'):
- f = get_long_le
- else:
- return None
- type = 'au'
- hdr_size = f(h[4:8])
- data_size = f(h[8:12])
- encoding = f(h[12:16])
- rate = f(h[16:20])
- nchannels = f(h[20:24])
- sample_size = 1 # default
- if encoding == 1:
- sample_bits = 'U'
- elif encoding == 2:
- sample_bits = 8
- elif encoding == 3:
- sample_bits = 16
- sample_size = 2
- else:
- sample_bits = '?'
- frame_size = sample_size * nchannels
- return type, rate, nchannels, data_size/frame_size, sample_bits
-
-tests.append(test_au)
-
-
-def test_hcom(h, f):
- if h[65:69] <> 'FSSD' or h[128:132] <> 'HCOM':
- return None
- divisor = get_long_be(h[128+16:128+20])
- return 'hcom', 22050/divisor, 1, -1, 8
-
-tests.append(test_hcom)
-
-
-def test_voc(h, f):
- if h[:20] <> 'Creative Voice File\032':
- return None
- sbseek = get_short_le(h[20:22])
- rate = 0
- if 0 <= sbseek < 500 and h[sbseek] == '\1':
- ratecode = ord(h[sbseek+4])
- rate = int(1000000.0 / (256 - ratecode))
- return 'voc', rate, 1, -1, 8
-
-tests.append(test_voc)
-
-
-def test_wav(h, f):
- # 'RIFF' <len> 'WAVE' 'fmt ' <len>
- if h[:4] <> 'RIFF' or h[8:12] <> 'WAVE' or h[12:16] <> 'fmt ':
- return None
- style = get_short_le(h[20:22])
- nchannels = get_short_le(h[22:24])
- rate = get_long_le(h[24:28])
- sample_bits = get_short_le(h[34:36])
- return 'wav', rate, nchannels, -1, sample_bits
-
-tests.append(test_wav)
-
-
-def test_8svx(h, f):
- if h[:4] <> 'FORM' or h[8:12] <> '8SVX':
- return None
- # Should decode it to get #channels -- assume always 1
- return '8svx', 0, 1, 0, 8
-
-tests.append(test_8svx)
-
-
-def test_sndt(h, f):
- if h[:5] == 'SOUND':
- nsamples = get_long_le(h[8:12])
- rate = get_short_le(h[20:22])
- return 'sndt', rate, 1, nsamples, 8
-
-tests.append(test_sndt)
-
-
-def test_sndr(h, f):
- if h[:2] == '\0\0':
- rate = get_short_le(h[2:4])
- if 4000 <= rate <= 25000:
- return 'sndr', rate, 1, -1, 8
-
-tests.append(test_sndr)
-
-
-#---------------------------------------------#
-# Subroutines to extract numbers from strings #
-#---------------------------------------------#
-
-def get_long_be(s):
- return (ord(s[0])<<24) | (ord(s[1])<<16) | (ord(s[2])<<8) | ord(s[3])
-
-def get_long_le(s):
- return (ord(s[3])<<24) | (ord(s[2])<<16) | (ord(s[1])<<8) | ord(s[0])
-
-def get_short_be(s):
- return (ord(s[0])<<8) | ord(s[1])
-
-def get_short_le(s):
- return (ord(s[1])<<8) | ord(s[0])
-
-
-#--------------------#
-# Small test program #
-#--------------------#
-
-def test():
- import sys
- recursive = 0
- if sys.argv[1:] and sys.argv[1] == '-r':
- del sys.argv[1:2]
- recursive = 1
- try:
- if sys.argv[1:]:
- testall(sys.argv[1:], recursive, 1)
- else:
- testall(['.'], recursive, 1)
- except KeyboardInterrupt:
- sys.stderr.write('\n[Interrupted]\n')
- sys.exit(1)
-
-def testall(list, recursive, toplevel):
- import sys
- import os
- for filename in list:
- if os.path.isdir(filename):
- print filename + '/:',
- if recursive or toplevel:
- print 'recursing down:'
- import glob
- names = glob.glob(os.path.join(filename, '*'))
- testall(names, recursive, 0)
- else:
- print '*** directory (use -r) ***'
- else:
- print filename + ':',
- sys.stdout.flush()
- try:
- print what(filename)
- except IOError:
- print '*** not found ***'
+from sndhdr import *
projects / python / commitdiff