bee_python 0.0.1

data/tools/epydoc/compat.py

@@ -0,0 +1,250 @@
+# epydoc -- Backwards compatibility
+#
+# Copyright (C) 2005 Edward Loper
+# Author: Edward Loper <edloper@loper.org>
+# URL: <http://epydoc.sf.net>
+#
+# $Id: compat.py,v 1.1 2009/11/26 13:20:38 casa Exp $
+
+"""
+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
+