code-ed5c19fca083/roundup/anypy/README.txt0000644000000000000000000000100413552724037016350 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. # vim: si code-ed5c19fca083/roundup/anypy/TODO.txt0000644000000000000000000000020013552724037016155 0ustar 00000000000000Python compatiblity TODO ~~~~~~~~~~~~~~~~~~~~~~~~ Remove support for Python versions < 2.7. As they are not supported anymore. code-ed5c19fca083/roundup/anypy/__init__.py0000644000000000000000000000025613552724037016773 0ustar 00000000000000""" roundup.anypy - compatibility layer for any Python 2.3+ """ VERSION = '.'.join(map(str, (0, 3, ))) code-ed5c19fca083/roundup/anypy/cmp_.py0000644000000000000000000000615513552724037016156 0ustar 00000000000000try: None < 0 def NoneAndDictComparable(v): return v except TypeError: # comparator to allow comparisons against None and dict # comparisons (these were allowed in Python 2, but aren't allowed # in Python 3 any more) class NoneAndDictComparable(object): def __init__(self, value): self.value = value def __cmp__(self, other): if not isinstance(other, self.__class__): raise TypeError('not comparable') if self.value == other.value: return 0 elif self.value is None: return -1 elif other.value is None: return 1 elif type(self.value) == tuple and type(other.value) == tuple: for lhs, rhs in zip(self.value, other.value): lhsCmp = NoneAndDictComparable(lhs) rhsCmp = NoneAndDictComparable(rhs) result = lhsCmp.__cmp__(rhsCmp) if result != 0: return result return len(self.value) - len(other.value) elif type(self.value) == dict and type(other.value) == dict: diff = len(self.value) - len(other.value) if diff == 0: lhsItems = tuple(sorted(self.value.items(), key=NoneAndDictComparable)) rhsItems = tuple(sorted(other.value.items(), key=NoneAndDictComparable)) return -1 if NoneAndDictComparable(lhsItems) < NoneAndDictComparable(rhsItems) else 1 else: return diff elif self.value < other.value: return -1 else: return 1 def __eq__(self, other): return self.__cmp__(other) == 0 def __ne__(self, other): return self.__cmp__(other) != 0 def __lt__(self, other): return self.__cmp__(other) < 0 def __le__(self, other): return self.__cmp__(other) <= 0 def __ge__(self, other): return self.__cmp__(other) >= 0 def __gt__(self, other): return self.__cmp__(other) > 0 def _test(): Comp = NoneAndDictComparable assert Comp(None) < Comp(0) assert Comp(None) < Comp('') assert Comp(None) < Comp({}) assert Comp((0, None)) < Comp((0, 0)) assert not Comp(0) < Comp(None) assert not Comp('') < Comp(None) assert not Comp({}) < Comp(None) assert not Comp((0, 0)) < Comp((0, None)) assert Comp((0, 0)) < Comp((0, 0, None)) assert Comp((0, None, None)) < Comp((0, 0, 0)) assert Comp(0) < Comp(1) assert Comp(1) > Comp(0) assert not Comp(1) < Comp(0) assert not Comp(0) > Comp(0) assert Comp({ 0: None }) < Comp({ 0: 0 }) assert Comp({ 0: 0 }) < Comp({ 0: 1 }) assert Comp({ 0: 0 }) == Comp({ 0: 0 }) assert Comp({ 0: 0 }) != Comp({ 0: 1 }) assert Comp({ 0: 0, 1: 1 }) > Comp({ 0: 1 }) assert Comp({ 0: 0, 1: 1 }) < Comp({ 0: 0, 2: 2 }) if __name__ == '__main__': _test() code-ed5c19fca083/roundup/anypy/cookie_.py0000644000000000000000000000050613552724037016642 0ustar 00000000000000 try: # Python 3+ from http import cookies as Cookie from http.cookies import CookieError, BaseCookie, SimpleCookie from http.cookies import _getdate as get_cookie_date except: # Python 2.5-2.7 from Cookie import CookieError, BaseCookie, SimpleCookie from Cookie import _getdate as get_cookie_date code-ed5c19fca083/roundup/anypy/dbm_.py0000644000000000000000000000062713552724037016137 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. 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-ed5c19fca083/roundup/anypy/email_.py0000644000000000000000000001167413552724037016470 0ustar 00000000000000import re import binascii import email from email import quoprimime, base64mime from email import charset as _charset if str == bytes: message_from_bytes = email.message_from_string message_from_binary_file = email.message_from_file else: message_from_bytes = email.message_from_bytes message_from_binary_file = email.message_from_binary_file ## please import this file if you are using the email module # 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 email.errors.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: BSPACE = b' ' last_word += BSPACE + word else: last_word += word collapsed.append((last_word, last_charset)) return collapsed code-ed5c19fca083/roundup/anypy/findargspec.py0000644000000000000000000000143713552724037017523 0ustar 00000000000000''' Wrapper for getargspec to support other callables and python 3 support In python 3 just uses getfullargspec which handles regular functions and classes with __call__ methods. ''' try: # Python 3+ from inspect import getfullargspec as getargspec findargspec = getargspec except: # Python 2.5-2.7 modified from https://bugs.python.org/issue20828 import inspect def findargspec(fn): if inspect.isfunction(fn) or inspect.ismethod(fn): inspectable = fn elif inspect.isclass(fn): inspectable = fn.__init__ elif hasattr(fn, '__call__'): inspectable = fn.__call__ else: inspectable = fn try: return inspect.getargspec(inspectable) except TypeError: raise code-ed5c19fca083/roundup/anypy/html.py0000644000000000000000000000051413552724037016175 0ustar 00000000000000try: from html import escape as html_escape_ # python 3 def html_escape(str, quote=False): # html_escape under python 3 sets quote to true by default # make it python 2 compatible return html_escape_(str, quote=quote) except ImportError: from cgi import escape as html_escape # python 2 fallback code-ed5c19fca083/roundup/anypy/http_.py0000644000000000000000000000027113552724037016347 0ustar 00000000000000try: # Python 3+ from http import client, server server.DEFAULT_ERROR_MESSAGE except: # Python 2.5-2.7 import httplib as client import BaseHTTPServer as server code-ed5c19fca083/roundup/anypy/my_input.py0000644000000000000000000000014613552724037017076 0ustar 00000000000000try: # Python 2. my_input = raw_input except NameError: # Python 3+. my_input = input code-ed5c19fca083/roundup/anypy/random_.py0000644000000000000000000000235113552724037016651 0ustar 00000000000000try: from secrets import choice, randbelow, token_bytes def seed(v = None): pass is_weak = False except ImportError: import os as _os import random as _random # prefer to use SystemRandom if it is available if hasattr(_random, 'SystemRandom'): def seed(v = None): pass _r = _random.SystemRandom() is_weak = False else: # don't completely throw away the existing state, but add some # more random state to the existing state def seed(v = None): import os, time _r.seed((_r.getstate(), v, hasattr(os, 'getpid') and os.getpid(), time.time())) # create our own instance so we don't mess with the global # random number generator _r = _random.Random() seed() is_weak = True choice = _r.choice def randbelow(i): return _r.randint(0, i - 1) if hasattr(_os, 'urandom'): def token_bytes(l): return _os.urandom(l) else: def token_bytes(l): _bchr = chr if str == bytes else lambda x: bytes((x,)) return b''.join([_bchr(_r.getrandbits(8)) for i in range(l)]) code-ed5c19fca083/roundup/anypy/strings.py0000644000000000000000000001036713552724037016731 0ustar 00000000000000# Roundup represents text internally using the native Python str type. # In Python 3, these are Unicode strings. In Python 2, these are # encoded using UTF-8, and the Python 2 unicode type is only used in a # few places, generally for interacting with external modules # requiring that type to be used. import sys _py3 = sys.version_info[0] > 2 import io if _py3: StringIO = io.StringIO else: StringIO = io.BytesIO def b2s(b): """Convert a UTF-8 encoded bytes object to the internal string format.""" if _py3: return b.decode('utf-8') else: return b def s2b(s): """Convert a string object to UTF-8 encoded bytes.""" if _py3: return s.encode('utf-8') else: return s def bs2b(s): """Convert a string object or UTF-8 encoded bytes to UTF-8 encoded bytes.""" if _py3: if isinstance(s, bytes): return s else: return s.encode('utf-8') else: return s def s2u(s, errors='strict'): """Convert a string object to a Unicode string.""" if _py3: return s else: return unicode(s, 'utf-8', errors) def u2s(u): """Convert a Unicode string to the internal string format.""" if _py3: return u else: return u.encode('utf-8') def us2u(s, errors='strict'): """Convert a string or Unicode string to a Unicode string.""" if _py3: return s else: if isinstance(s, unicode): return s else: return unicode(s, 'utf-8', errors) def us2s(u): """Convert a string or Unicode string to the internal string format.""" if _py3: return u else: if isinstance(u, unicode): return u.encode('utf-8') else: return u def uany2s(u): """Convert a Unicode string or other object to the internal string format. Objects that are not Unicode strings are passed to str().""" if _py3: return str(u) else: if isinstance(u, unicode): return u.encode('utf-8') else: return str(u) def is_us(s): """Return whether an object is a string or Unicode string.""" if _py3: return isinstance(s, str) else: return isinstance(s, str) or isinstance(s, unicode) def uchr(c): """Return the Unicode string containing the given character.""" if _py3: return chr(c) else: return unichr(c) # CSV files used for export and import represent strings in the style # used by repr in Python 2; this means that each byte of the UTF-8 # representation is represented by a \x escape if not a printable # ASCII character. When such a representation is interpreted by eval # in Python 3, the effect is that the Unicode characters in the # resulting string correspond to UTF-8 bytes, so encoding the string # as ISO-8859-1 produces the correct byte-string which must then be # decoded as UTF-8 to produce the correct Unicode string. The same # representations are also used for journal storage in RDBMS # databases, so that the database can be compatible between Python 2 # and Python 3. def repr_export(v): """Return a Python-2-style representation of a value for export to CSV.""" if _py3: if isinstance(v, str): return repr(s2b(v))[1:] elif isinstance(v, dict): repr_vals = [] for key, value in sorted(v.items()): repr_vals.append('%s: %s' % (repr_export(key), repr_export(value))) return '{%s}' % ', '.join(repr_vals) else: return repr(v) else: return repr(v) def eval_import(s): """Evaluate a Python-2-style value imported from a CSV file.""" if _py3: v = eval(s) if isinstance(v, str): return v.encode('iso-8859-1').decode('utf-8') elif isinstance(v, dict): v_mod = {} for key, value in v.items(): if isinstance(key, str): key = key.encode('iso-8859-1').decode('utf-8') if isinstance(value, str): value = value.encode('iso-8859-1').decode('utf-8') v_mod[key] = value return v_mod else: return v else: return eval(s) code-ed5c19fca083/roundup/anypy/urllib_.py0000644000000000000000000000050413552724037016660 0ustar 00000000000000 try: # Python 3+ from urllib.parse import quote, unquote, urlencode, urlparse, parse_qs, \ urlunparse from urllib.request import urlopen except: # Python 2.5-2.7 from urllib import quote, unquote, urlencode from urllib2 import urlopen from urlparse import urlparse, parse_qs, urlunparse code-ed5c19fca083/roundup/anypy/xmlrpc_.py0000644000000000000000000000033313552724037016674 0ustar 00000000000000try: # Python 3+. from xmlrpc import client, server server.SimpleXMLRPCDispatcher except (ImportError, AttributeError): # Python 2. import xmlrpclib as client import SimpleXMLRPCServer as server