code-76daabfdbc8d/roundup/anypy/README.txt0000644000000000000000000000307511754671160016602 0ustar 00000000000000roundup.anypy package - Python version compatibility layer ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Roundup currently supports Python 2.3 to 2.6; however, some modules have been introduced, while others have been deprecated. The modules in this package provide the functionalities which are used by Roundup - adapting the most recent Python usage - using new built-in functionality - avoiding deprecation warnings Use the modules in this package to preserve Roundup's compatibility. sets_: sets compatibility module ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Since Python 2.4, there is a built-in type 'set'; therefore, the 'sets' module is deprecated since version 2.6. As far as Roundup is concerned, the usage is identical; see http://docs.python.org/library/sets.html#comparison-to-the-built-in-set-types Uses the built-in type 'set' if available, and thus avoids deprecation warnings. Simple usage: Change all:: from sets import Set to:: from roundup.anypy.sets_ import set and use 'set' instead of 'Set' (or sets.Set, respectively). To avoid unnecessary imports, you can:: try: set except NameError: from roundup.anypy.sets_ import set hashlib_: md5/sha/hashlib compatibility ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The md5 and sha modules are deprecated since Python 2.6; the hashlib module, introduced with Python 2.5, is recommended instead. Change all:: import md5 md5.md5(), md5.new() import sha sha.sha(), sha.new() to:: from roundup.anypy.hashlib_ import md5 md5() from roundup.anypy.hashlib_ import sha1 sha1() # vim: si code-76daabfdbc8d/roundup/anypy/TODO.txt0000644000000000000000000000033511754671160016406 0ustar 00000000000000Python compatiblity TODO ~~~~~~~~~~~~~~~~~~~~~~~~ - the popen2 module is deprecated as of Python 2.6; the subprocess module is available since Python 2.4, thus a roundup.anypy.subprocess_ module is needed # vim: si code-76daabfdbc8d/roundup/anypy/__init__.py0000644000000000000000000000030111754671160017202 0ustar 00000000000000""" roundup.anypy - compatibility layer for any Python 2.3+ """ VERSION = '.'.join(map(str, (0, 1, # hashlib_, sets_ ))) code-76daabfdbc8d/roundup/anypy/cookie_.py0000644000000000000000000000044111754671160017060 0ustar 00000000000000 try: from http import cookies as Cookie from http.cookies import CookieError, BaseCookie, SimpleCookie from http.cookies import _getdate as get_cookie_date except: from Cookie import CookieError, BaseCookie, SimpleCookie from Cookie import _getdate as get_cookie_date code-76daabfdbc8d/roundup/anypy/dbm_.py0000644000000000000000000000106511754671160016354 0ustar 00000000000000# In Python 3 the "anydbm" module was renamed to be "dbm" which is now a # package containing the various implementations. The "wichdb" module's # whichdb() function was moved to the new "dbm" module. import sys if sys.version_info[:2] < (2, 6): def key_in(db, key): return db.has_key(key) else: def key_in(db, key): return key in db try: # old school first because <3 had a "dbm" module too... import anydbm from whichdb import whichdb except ImportError: # python 3+ import dbm as anydbm whichdb = anydbm.whichdb code-76daabfdbc8d/roundup/anypy/email_.py0000644000000000000000000001204411754671160016700 0ustar 00000000000000import re import binascii from email import quoprimime, base64mime try: # Python 2.5+ from email.parser import FeedParser except ImportError: # Python 2.4 try : from email.Parser import FeedParser except ImportError: from email.Parser import Parser class FeedParser: def __init__(self): self.content = [] def feed(self, s): self.content.append(s) def close(self): p = Parser() return p.parsestr(''.join(self.content)) # Match encoded-word strings in the form =?charset?q?Hello_World?= ecre = re.compile(r''' =\? # literal =? (?P[^?]*?) # non-greedy up to the next ? is the charset \? # literal ? (?P[qb]) # either a "q" or a "b", case insensitive \? # literal ? (?P.*?) # non-greedy up to the next ?= is the encoded string \?= # literal ?= ''', re.VERBOSE | re.IGNORECASE | re.MULTILINE) # Fixed header parser, see my proposed patch and discussions: # http://bugs.python.org/issue1079 "decode_header does not follow RFC 2047" # http://bugs.python.org/issue1467619 "Header.decode_header eats up spaces" # This implements the decode_header specific parts of my proposed patch # backported to python2.X def decode_header(header): """Decode a message header value without converting charset. Returns a list of (string, charset) pairs containing each of the decoded parts of the header. Charset is None for non-encoded parts of the header, otherwise a lower-case string containing the name of the character set specified in the encoded string. header may be a string that may or may not contain RFC2047 encoded words, or it may be a Header object. An email.errors.HeaderParseError may be raised when certain decoding error occurs (e.g. a base64 decoding exception). """ # If it is a Header object, we can just return the encoded chunks. if hasattr(header, '_chunks'): return [(_charset._encode(string, str(charset)), str(charset)) for string, charset in header._chunks] # If no encoding, just return the header with no charset. if not ecre.search(header): return [(header, None)] # First step is to parse all the encoded parts into triplets of the form # (encoded_string, encoding, charset). For unencoded strings, the last # two parts will be None. words = [] for line in header.splitlines(): parts = ecre.split(line) first = True while parts: unencoded = parts.pop(0) if first: unencoded = unencoded.lstrip() first = False if unencoded: words.append((unencoded, None, None)) if parts: charset = parts.pop(0).lower() encoding = parts.pop(0).lower() encoded = parts.pop(0) words.append((encoded, encoding, charset)) # Now loop over words and remove words that consist of whitespace # between two encoded strings. import sys droplist = [] for n, w in enumerate(words): if n>1 and w[1] and words[n-2][1] and words[n-1][0].isspace(): droplist.append(n-1) for d in reversed(droplist): del words[d] # The next step is to decode each encoded word by applying the reverse # base64 or quopri transformation. decoded_words is now a list of the # form (decoded_word, charset). decoded_words = [] for encoded_string, encoding, charset in words: if encoding is None: # This is an unencoded word. decoded_words.append((encoded_string, charset)) elif encoding == 'q': word = quoprimime.header_decode(encoded_string) decoded_words.append((word, charset)) elif encoding == 'b': paderr = len(encoded_string) % 4 # Postel's law: add missing padding if paderr: encoded_string += '==='[:4 - paderr] try: word = base64mime.decode(encoded_string) except binascii.Error: raise HeaderParseError('Base64 decoding error') else: decoded_words.append((word, charset)) else: raise AssertionError('Unexpected encoding: ' + encoding) # Now convert all words to bytes and collapse consecutive runs of # similarly encoded words. collapsed = [] last_word = last_charset = None for word, charset in decoded_words: if isinstance(word, str): pass if last_word is None: last_word = word last_charset = charset elif charset != last_charset: collapsed.append((last_word, last_charset)) last_word = word last_charset = charset elif last_charset is None: last_word += BSPACE + word else: last_word += word collapsed.append((last_word, last_charset)) return collapsed code-76daabfdbc8d/roundup/anypy/hashlib_.py0000644000000000000000000000052411754671160017223 0ustar 00000000000000""" anypy.hashlib_: encapsulation of hashlib/md5/sha1/sha """ try: from hashlib import md5, sha1 # new in Python 2.5 shamodule = sha1 except ImportError: from md5 import md5 # deprecated in Python 2.6 from sha import sha as sha1 # deprecated in Python 2.6 import sha as shamodule # vim: ts=8 sts=4 sw=4 si code-76daabfdbc8d/roundup/anypy/http_.py0000644000000000000000000000010711754671160016565 0ustar 00000000000000try: from http import client except: import httplib as client code-76daabfdbc8d/roundup/anypy/io_.py0000644000000000000000000000015511754671160016220 0ustar 00000000000000 try: from io import StringIO, BytesIO except: from StringIO import StringIO BytesIO = StringIO code-76daabfdbc8d/roundup/anypy/sets_.py0000644000000000000000000000122511754671160016566 0ustar 00000000000000""" anypy.sets_: sets compatibility module uses the built-in type 'set' if available, and thus avoids deprecation warnings. Simple usage: Change all from sets import Set to from roundup.anypy.sets_ import set and use 'set' instead of 'Set'. To avoid unnecessary imports, you can: try: set except NameError: from roundup.anypy.sets_ import set see: http://docs.python.org/library/sets.html#comparison-to-the-built-in-set-types """ try: set = set # built-in since Python 2.4 except (NameError, TypeError): from sets import Set as set # deprecated as of Python 2.6 # vim: ts=8 sts=4 sw=4 si et code-76daabfdbc8d/roundup/anypy/urllib_.py0000644000000000000000000000017211754671160017101 0ustar 00000000000000 try: from urllib.parse import quote, urlparse except: from urllib import quote from urlparse import urlparse