aifc, sunau: make rate an int; os: restruct; ospath: obsolete; rfc822:

date and addr parsing; string: force result of atof to float and
support atoi, atol, atof in strop; tzparcs: don't call test().

1 files changed, 348 insertions, 0 deletions

diff --git a/Lib/dospath.py b/Lib/dospath.py
new file mode 100644
index 0000000..1479e1b
--- /dev/null
+++ b/Lib/dospath.py
@@ -0,0 +1,348 @@
+# Module 'dospath' -- common operations on DOS pathnames
+
+import os
+import stat
+import string
+
+
+# Normalize the case of a pathname.
+# On MS-DOS it maps the pathname to lowercase, turns slashes into
+# backslashes and maps invalid consecutive characters to a single '_'.
+# Other normalizations (such as optimizing '../' away) are not allowed
+# (this is done by normpath).
+
+mapchar = '_'
+
+def normcase(s):
+	res, s = splitdrive(s)
+	for c in s:
+		if c in '/\\':
+			res = res + os.sep
+		elif c == '.' and res[-1:] == os.sep:
+			res = res + mapchar + c
+		elif ord(c) < 32 or c in ' "*+,:;<=>?[]|':
+			if res[-1:] != mapchar:
+				res = res + mapchar
+		else:
+			res = res + c
+	return string.lower(res)
+
+
+# Return wheter a path is absolute.
+# Trivial in Posix, harder on the Mac or MS-DOS.
+# For DOS it is absolute if it starts with a slash or backslash (current
+# volume), or if a pathname after the volume letter and colon starts with
+# a slash or backslash.
+
+def isabs(s):
+	s = splitdrive(s)[1]
+	return s != '' and s[:1] in '/\\'
+
+
+# Join two pathnames.
+# Ignore the first part if the second part is absolute.
+# Insert a '/' unless the first part is empty or already ends in '/'.
+
+def join(a, b):
+	if isabs(b): return b
+	if a == '' or a[-1:] in '/\\': return a + b
+	# Note: join('x', '') returns 'x/'; is this what we want?
+	return a + os.sep + b
+
+
+# Split a path in a drive specification (a drive letter followed by a
+# colon) and the path specification.
+# It is always true that drivespec + pathspec == p
+def splitdrive(p):
+	if p[1:2] == ':':
+		return p[0:2], p[2:]
+	return '', p
+
+
+# Split a path in head (everything up to the last '/') and tail (the
+# rest).  If the original path ends in '/' but is not the root, this
+# '/' is stripped.  After the trailing '/' is stripped, the invariant
+# join(head, tail) == p holds.
+# The resulting head won't end in '/' unless it is the root.
+
+def split(p):
+	d, p = splitdrive(p)
+	slashes = ''
+	while p and p[-1:] in '/\\':
+		slashes = slashes + p[-1]
+		p = p[:-1]
+	if p == '':
+		p = p + slashes
+	head, tail = '', ''
+	for c in p:
+		tail = tail + c
+		if c in '/\\':
+			head, tail = head + tail, ''
+	slashes = ''
+	while head and head[-1:] in '/\\':
+		slashes = slashes + head[-1]
+		head = head[:-1]
+	if head == '':
+		head = head + slashes
+	return d + head, tail
+
+
+# Split a path in root and extension.
+# The extension is everything starting at the first dot in the last
+# pathname component; the root is everything before that.
+# It is always true that root + ext == p.
+
+def splitext(p):
+	root, ext = '', ''
+	for c in p:
+		if c in '/\\':
+			root, ext = root + ext + c, ''
+		elif c == '.' or ext:
+			ext = ext + c
+		else:
+			root = root + c
+	return root, ext
+
+
+# Return the tail (basename) part of a path.
+
+def basename(p):
+	return split(p)[1]
+
+
+# Return the head (dirname) part of a path.
+
+def dirname(p):
+	return split(p)[0]
+
+
+# Return the longest prefix of all list elements.
+
+def commonprefix(m):
+	if not m: return ''
+	prefix = m[0]
+	for item in m:
+		for i in range(len(prefix)):
+			if prefix[:i+1] <> item[:i+1]:
+				prefix = prefix[:i]
+				if i == 0: return ''
+				break
+	return prefix
+
+
+# Is a path a symbolic link?
+# This will always return false on systems where posix.lstat doesn't exist.
+
+def islink(path):
+	return false
+
+
+# Does a path exist?
+# This is false for dangling symbolic links.
+
+def exists(path):
+	try:
+		st = os.stat(path)
+	except os.error:
+		return 0
+	return 1
+
+
+# Is a path a dos directory?
+# This follows symbolic links, so both islink() and isdir() can be true
+# for the same path.
+
+def isdir(path):
+	try:
+		st = os.stat(path)
+	except os.error:
+		return 0
+	return stat.S_ISDIR(st[stat.ST_MODE])
+
+
+# Is a path a regular file?
+# This follows symbolic links, so both islink() and isdir() can be true
+# for the same path.
+
+def isfile(path):
+	try:
+		st = os.stat(path)
+	except os.error:
+		return 0
+	return stat.S_ISREG(st[stat.ST_MODE])
+
+
+# Are two filenames really pointing to the same file?
+
+def samefile(f1, f2):
+	s1 = os.stat(f1)
+	s2 = os.stat(f2)
+	return samestat(s1, s2)
+
+
+# Are two open files really referencing the same file?
+# (Not necessarily the same file descriptor!)
+# XXX THIS IS BROKEN UNDER DOS! ST_INO seems to indicate number of reads?
+
+def sameopenfile(fp1, fp2):
+	s1 = os.fstat(fp1.fileno())
+	s2 = os.fstat(fp2.fileno())
+	return samestat(s1, s2)
+
+
+# Are two stat buffers (obtained from stat, fstat or lstat)
+# describing the same file?
+
+def samestat(s1, s2):
+	return s1[stat.ST_INO] == s2[stat.ST_INO] and \
+		s1[stat.ST_DEV] == s2[stat.ST_DEV]
+
+
+# Is a path a mount point?
+# XXX This degenerates in: 'is this the root?' on DOS
+
+def ismount(path):
+	return isabs(splitdrive(path)[1])
+
+
+# Directory tree walk.
+# For each directory under top (including top itself, but excluding
+# '.' and '..'), func(arg, dirname, filenames) is called, where
+# dirname is the name of the directory and filenames is the list
+# files files (and subdirectories etc.) in the directory.
+# The func may modify the filenames list, to implement a filter,
+# or to impose a different order of visiting.
+
+def walk(top, func, arg):
+	try:
+		names = os.listdir(top)
+	except os.error:
+		return
+	func(arg, top, names)
+	exceptions = ('.', '..')
+	for name in names:
+		if name not in exceptions:
+			name = join(top, name)
+			if isdir(name):
+				walk(name, func, arg)
+
+
+# Expand paths beginning with '~' or '~user'.
+# '~' means $HOME; '~user' means that user's home directory.
+# If the path doesn't begin with '~', or if the user or $HOME is unknown,
+# the path is returned unchanged (leaving error reporting to whatever
+# function is called with the expanded path as argument).
+# See also module 'glob' for expansion of *, ? and [...] in pathnames.
+# (A function should also be defined to do full *sh-style environment
+# variable expansion.)
+
+def expanduser(path):
+	if path[:1] <> '~':
+		return path
+	i, n = 1, len(path)
+	while i < n and path[i] not in '/\\':
+		i = i+1
+	if i == 1:
+		if not os.environ.has_key('HOME'):
+			return path
+		userhome = os.environ['HOME']
+	else:
+		return path
+	return userhome + path[i:]
+
+
+# Expand paths containing shell variable substitutions.
+# The following rules apply:
+#	- no expansion within single quotes
+#	- no escape character, except for '$$' which is translated into '$'
+#	- ${varname} is accepted.
+#	- varnames can be made out of letters, digits and the character '_'
+# XXX With COMMAND.COM you can use any characters in a variable name,
+# XXX except '^|<>='.
+
+varchars = string.letters + string.digits + '_-'
+
+def expandvars(path):
+	if '$' not in path:
+		return path
+	res = ''
+	index = 0
+	pathlen = len(path)
+	while index < pathlen:
+		c = path[index]
+		if c == '\'':	# no expansion within single quotes
+			path = path[index + 1:]
+			pathlen = len(path)
+			try:
+				index = string.index(path, '\'')
+				res = res + '\'' + path[:index + 1]
+			except string.index_error:
+				res = res + path
+				index = pathlen -1
+		elif c == '$':	# variable or '$$'
+			if path[index + 1:index + 2] == '$':
+				res = res + c
+				index = index + 1
+			elif path[index + 1:index + 2] == '{':
+				path = path[index+2:]
+				pathlen = len(path)
+				try:
+					index = string.index(path, '}')
+					var = path[:index]
+					if os.environ.has_key(var):
+						res = res + os.environ[var]
+				except string.index_error:
+					res = res + path
+					index = pathlen - 1
+			else:
+				var = ''
+				index = index + 1
+				c = path[index:index + 1]
+				while c != '' and c in varchars:
+					var = var + c
+					index = index + 1
+					c = path[index:index + 1]
+				if os.environ.has_key(var):
+					res = res + os.environ[var]
+				if c != '':
+					res = res + c
+		else:
+			res = res + c
+		index = index + 1
+	return res
+
+
+# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
+# Also, components of the path are silently truncated to 8+3 notation.
+
+def normpath(path):
+	path = normcase(path)
+	prefix, path = splitdrive(path)
+	while path[:1] == os.sep:
+		prefix = prefix + os.sep
+		path = path[1:]
+	comps = string.splitfields(path, os.sep)
+	i = 0
+	while i < len(comps):
+		if comps[i] == '.':
+			del comps[i]
+		elif comps[i] == '..' and i > 0 and \
+					  comps[i-1] not in ('', '..'):
+			del comps[i-1:i+1]
+			i = i-1
+		elif comps[i] == '' and i > 0 and comps[i-1] <> '':
+			del comps[i]
+		elif '.' in comps[i]:
+			comp = string.splitfields(comps[i], '.')
+			comps[i] = comp[0][:8] + '.' + comp[1][:3]
+			i = i+1
+		elif len(comps[i]) > 8:
+			comps[i] = comps[i][:8]
+			i = i+1
+		else:
+			i = i+1
+	# If the path is now empty, substitute '.'
+	if not prefix and not comps:
+		comps.append('.')
+	return prefix + string.joinfields(comps, os.sep)
+