python/helpers/epydoc/compat.py - platform/tools/idea - Git at Google

 # epydoc -- Backwards compatibility
 #
 # Copyright (C) 2005 Edward Loper
 # Author: Edward Loper <edloper@loper.org>
 # URL: <http://epydoc.sf.net>
 #
 # $Id: util.py 956 2006-03-10 01:30:51Z edloper $

 """
 Backwards compatibility with previous versions of Python.

 This module provides backwards compatibility by defining several
 functions and classes that were not available in earlier versions of
 Python.  Intented usage:

     >>> from epydoc.compat import *

 Currently, epydoc requires Python 2.3+.
 """
 __docformat__ = 'epytext'

 ######################################################################
 #{ New in Python 2.4
 ######################################################################

 # set
 try:
     set
 except NameError:
     try:
         from sets import Set as set, ImmutableSet as frozenset
     except ImportError:
         pass # use fallback, in the next section.

 # sorted
 try:
     sorted
 except NameError:
     def sorted(iterable, cmp=None, key=None, reverse=False):
         if key is None:
             elts = list(iterable)
         else:
             elts = [(key(v), v) for v in iterable]

         if reverse: elts.reverse() # stable sort.
         if cmp is None: elts.sort()
         else: elts.sort(cmp)
         if reverse: elts.reverse()

         if key is None:
             return elts
         else:
             return [v for (k,v) in elts]

 # reversed
 try:
     reversed
 except NameError:
     def reversed(iterable):
         elts = list(iterable)
         elts.reverse()
         return elts

 ######################################################################
 #{ New in Python 2.3
 ######################################################################
 # Below is my initial attempt at backporting enough code that
 # epydoc 3 would run under python 2.2.  However, I'm starting
 # to think that it's not worth the trouble.  At the very least,
 # epydoc's current unicode handling still doesn't work under
 # 2.2 (after the backports below), since the 'xmlcharrefreplace'
 # error handler was introduced in python 2.3.

 # # basestring
 # try:
 #     basestring
 # except NameError:
 #     basestring = (str, unicode)

 # # sum
 # try:
 #     sum
 # except NameError:
 #     def _add(a,b): return a+b
 #     def sum(vals): return reduce(_add, vals, 0)

 # # True & False
 # try:
 #     True
 # except NameError:
 #     True = 1
 #     False = 0

 # # enumerate
 # try:
 #     enumerate
 # except NameError:
 #     def enumerate(iterable):
 #         lst = list(iterable)
 #         return zip(range(len(lst)), lst)

 # # set
 # try:
 #     set
 # except NameError:
 #     class set(dict):
 #         def __init__(self, elts=()):
 #             dict.__init__(self, [(e,1) for e in elts])
 #         def __repr__(self):
 #             return 'set(%r)' % list(self)
 #         def add(self, key): self[key] = 1
 #         def copy(self):
 #             return set(dict.copy(self))
 #         def difference(self, other):
 #             return set([v for v in self if v not in other])
 #         def difference_udpate(self, other):
 #             newval = self.difference(other)
 #             self.clear(); self.update(newval)
 #         def discard(self, elt):
 #             try: del self[elt]
 #             except: pass
 #         def intersection(self, other):
 #             return self.copy().update(other)
 #         def intersection_update(self, other):
 #             newval = self.intersection(other)
 #             self.clear(); self.update(newval)
 #         def issubset(self, other):
 #             for elt in self:
 #                 if elt not in other: return False
 #             return True
 #         def issuperset(self, other):
 #             for elt in other:
 #                 if elt not in self: return False
 #             return True
 #         def pop(self): self.popitem()[0]
 #         def remove(self, elt): del self[elt]
 #         def symmetric_difference(self, other):
 #             return set([v for v in list(self)+list(other)
 #                         if (v in self)^(v in other)])
 #         def symmatric_difference_update(self, other):
 #             newval = self.symmetric_difference(other)
 #             self.clear(); self.update(newval)
 #         def union(self, other):
 #             return set([v for v in list(self)+list(other)
 #                         if (v in self) or (v in other)])
 #         def union_update(self, other):
 #             newval = self.union(other)
 #             self.clear(); self.update(newval)
 #         def update(self, other):
 #             dict.update(self, set(other))

 # # optparse module
 # try:
 #     import optparse
 # except ImportError:
 #     import new, sys, getopt
 #     class _OptionVals:
 #         def __init__(self, vals): self.__dict__.update(vals)
 #     class OptionParser:
 #         def __init__(self, usage=None, version=None):
 #             self.usage = usage
 #             self.version = version
 #             self.shortops = ['h']
 #             self.longops = []
 #             self.option_specs = {}
 #             self.defaults = {}
 #         def fail(self, message, exitval=1):
 #             print >>sys.stderr, message
 #             system.exit(exitval)
 #         def add_option_group(self, group): pass
 #         def set_defaults(self, **defaults):
 #             self.defaults = defaults.copy()
 #         def parse_args(self):
 #             try:
 #                 (opts, names) = getopt.getopt(sys.argv[1:],
 #                                               ''.join(self.shortops),
 #                                               self.longops)
 #             except getopt.GetoptError, e:
 #                 self.fail(e)

 #             options = self.defaults.copy()
 #             for (opt,val) in opts:
 #                 if opt == '-h':
 #                     self.fail('No help available')
 #                 if opt not in self.option_specs:
 #                     self.fail('Unknown option %s' % opt)
 #                 (action, dest, const) = self.option_specs[opt]
 #                 if action == 'store':
 #                     options[dest] = val
 #                 elif action == 'store_const':
 #                     options[dest] = const
 #                 elif action == 'count':
 #                     options[dest] = options.get(dest,0)+1
 #                 elif action == 'append':
 #                     options.setdefault(dest, []).append(val)
 #                 else:
 #                     self.fail('unsupported action: %s' % action)
 #             for (action,dest,const) in self.option_specs.values():
 #                 if dest not in options:
 #                     if action == 'count': options[dest] = 0
 #                     elif action == 'append': options[dest] = []
 #                     else: options[dest] = None
 #             for name in names:
 #                 if name.startswith('-'):
 #                     self.fail('names must follow options')
 #             return _OptionVals(options), names
 #     class OptionGroup:
 #         def __init__(self, optparser, name):
 #             self.optparser = optparser
 #             self.name = name

 #         def add_option(self, *args, **kwargs):
 #             action = 'store'
 #             dest = None
 #             const = None
 #             for (key,val) in kwargs.items():
 #                 if key == 'action': action = val
 #                 elif key == 'dest': dest = val
 #                 elif key == 'const': const = val
 #                 elif key in ('help', 'metavar'): pass
 #                 else: self.fail('unsupported: %s' % key)

 #             if action not in ('store_const', 'store_true', 'store_false',
 #                               'store', 'count', 'append'):
 #                 self.fail('unsupported action: %s' % action)

 #             optparser = self.optparser
 #             for arg in args:
 #                 if arg.startswith('--'):
 #                     optparser.longops.append(arg[2:])
 #                 elif arg.startswith('-') and len(arg)==2:
 #                     optparser.shortops += arg[1]
 #                     if action in ('store', 'append'):
 #                         optparser.shortops += ':'
 #                 else:
 #                     self.fail('bad option name %s' % arg)
 #                 if action == 'store_true':
 #                     (action, const) = ('store_const', True)
 #                 if action == 'store_false':
 #                     (action, const) = ('store_const', False)
 #                 optparser.option_specs[arg] = (action, dest, const)

 #     # Install a fake module.
 #     optparse = new.module('optparse')
 #     optparse.OptionParser = OptionParser
 #     optparse.OptionGroup = OptionGroup
 #     sys.modules['optparse'] = optparse
 #     # Clean up
 #     del OptionParser, OptionGroup
	# epydoc -- Backwards compatibility
	#
	# Copyright (C) 2005 Edward Loper
	# Author: Edward Loper <edloper@loper.org>
	# URL: <http://epydoc.sf.net>
	#
	# $Id: util.py 956 2006-03-10 01:30:51Z edloper $

	"""
	Backwards compatibility with previous versions of Python.

	This module provides backwards compatibility by defining several
	functions and classes that were not available in earlier versions of
	Python. Intented usage:

	>>> from epydoc.compat import *

	Currently, epydoc requires Python 2.3+.
	"""
	__docformat__ = 'epytext'

	######################################################################
	#{ New in Python 2.4
	######################################################################

	# set
	try:
	set
	except NameError:
	try:
	from sets import Set as set, ImmutableSet as frozenset
	except ImportError:
	pass # use fallback, in the next section.

	# sorted
	try:
	sorted
	except NameError:
	def sorted(iterable, cmp=None, key=None, reverse=False):
	if key is None:
	elts = list(iterable)
	else:
	elts = [(key(v), v) for v in iterable]

	if reverse: elts.reverse() # stable sort.
	if cmp is None: elts.sort()
	else: elts.sort(cmp)
	if reverse: elts.reverse()

	if key is None:
	return elts
	else:
	return [v for (k,v) in elts]

	# reversed
	try:
	reversed
	except NameError:
	def reversed(iterable):
	elts = list(iterable)
	elts.reverse()
	return elts

	######################################################################
	#{ New in Python 2.3
	######################################################################
	# Below is my initial attempt at backporting enough code that
	# epydoc 3 would run under python 2.2. However, I'm starting
	# to think that it's not worth the trouble. At the very least,
	# epydoc's current unicode handling still doesn't work under
	# 2.2 (after the backports below), since the 'xmlcharrefreplace'
	# error handler was introduced in python 2.3.

	# # basestring
	# try:
	# basestring
	# except NameError:
	# basestring = (str, unicode)

	# # sum
	# try:
	# sum
	# except NameError:
	# def _add(a,b): return a+b
	# def sum(vals): return reduce(_add, vals, 0)

	# # True & False
	# try:
	# True
	# except NameError:
	# True = 1
	# False = 0

	# # enumerate
	# try:
	# enumerate
	# except NameError:
	# def enumerate(iterable):
	# lst = list(iterable)
	# return zip(range(len(lst)), lst)

	# # set
	# try:
	# set
	# except NameError:
	# class set(dict):
	# def __init__(self, elts=()):
	# dict.__init__(self, [(e,1) for e in elts])
	# def __repr__(self):
	# return 'set(%r)' % list(self)
	# def add(self, key): self[key] = 1
	# def copy(self):
	# return set(dict.copy(self))
	# def difference(self, other):
	# return set([v for v in self if v not in other])
	# def difference_udpate(self, other):
	# newval = self.difference(other)
	# self.clear(); self.update(newval)
	# def discard(self, elt):
	# try: del self[elt]
	# except: pass
	# def intersection(self, other):
	# return self.copy().update(other)
	# def intersection_update(self, other):
	# newval = self.intersection(other)
	# self.clear(); self.update(newval)
	# def issubset(self, other):
	# for elt in self:
	# if elt not in other: return False
	# return True
	# def issuperset(self, other):
	# for elt in other:
	# if elt not in self: return False
	# return True
	# def pop(self): self.popitem()[0]
	# def remove(self, elt): del self[elt]
	# def symmetric_difference(self, other):
	# return set([v for v in list(self)+list(other)
	# if (v in self)^(v in other)])
	# def symmatric_difference_update(self, other):
	# newval = self.symmetric_difference(other)
	# self.clear(); self.update(newval)
	# def union(self, other):
	# return set([v for v in list(self)+list(other)
	# if (v in self) or (v in other)])
	# def union_update(self, other):
	# newval = self.union(other)
	# self.clear(); self.update(newval)
	# def update(self, other):
	# dict.update(self, set(other))

	# # optparse module
	# try:
	# import optparse
	# except ImportError:
	# import new, sys, getopt
	# class _OptionVals:
	# def __init__(self, vals): self.__dict__.update(vals)
	# class OptionParser:
	# def __init__(self, usage=None, version=None):
	# self.usage = usage
	# self.version = version
	# self.shortops = ['h']
	# self.longops = []
	# self.option_specs = {}
	# self.defaults = {}
	# def fail(self, message, exitval=1):
	# print >>sys.stderr, message
	# system.exit(exitval)
	# def add_option_group(self, group): pass
	# def set_defaults(self, **defaults):
	# self.defaults = defaults.copy()
	# def parse_args(self):
	# try:
	# (opts, names) = getopt.getopt(sys.argv[1:],
	# ''.join(self.shortops),
	# self.longops)
	# except getopt.GetoptError, e:
	# self.fail(e)

	# options = self.defaults.copy()
	# for (opt,val) in opts:
	# if opt == '-h':
	# self.fail('No help available')
	# if opt not in self.option_specs:
	# self.fail('Unknown option %s' % opt)
	# (action, dest, const) = self.option_specs[opt]
	# if action == 'store':
	# options[dest] = val
	# elif action == 'store_const':
	# options[dest] = const
	# elif action == 'count':
	# options[dest] = options.get(dest,0)+1
	# elif action == 'append':
	# options.setdefault(dest, []).append(val)
	# else:
	# self.fail('unsupported action: %s' % action)
	# for (action,dest,const) in self.option_specs.values():
	# if dest not in options:
	# if action == 'count': options[dest] = 0
	# elif action == 'append': options[dest] = []
	# else: options[dest] = None
	# for name in names:
	# if name.startswith('-'):
	# self.fail('names must follow options')
	# return _OptionVals(options), names
	# class OptionGroup:
	# def __init__(self, optparser, name):
	# self.optparser = optparser
	# self.name = name

	# def add_option(self, args, *kwargs):
	# action = 'store'
	# dest = None
	# const = None
	# for (key,val) in kwargs.items():
	# if key == 'action': action = val
	# elif key == 'dest': dest = val
	# elif key == 'const': const = val
	# elif key in ('help', 'metavar'): pass
	# else: self.fail('unsupported: %s' % key)

	# if action not in ('store_const', 'store_true', 'store_false',
	# 'store', 'count', 'append'):
	# self.fail('unsupported action: %s' % action)

	# optparser = self.optparser
	# for arg in args:
	# if arg.startswith('--'):
	# optparser.longops.append(arg[2:])
	# elif arg.startswith('-') and len(arg)==2:
	# optparser.shortops += arg[1]
	# if action in ('store', 'append'):
	# optparser.shortops += ':'
	# else:
	# self.fail('bad option name %s' % arg)
	# if action == 'store_true':
	# (action, const) = ('store_const', True)
	# if action == 'store_false':
	# (action, const) = ('store_const', False)
	# optparser.option_specs[arg] = (action, dest, const)

	# # Install a fake module.
	# optparse = new.module('optparse')
	# optparse.OptionParser = OptionParser
	# optparse.OptionGroup = OptionGroup
	# sys.modules['optparse'] = optparse
	# # Clean up
	# del OptionParser, OptionGroup