text: """
  Python 2.6, 2.7, and 3.x compatibility.
  
  """
  import sys
  
  
  is_py2 = sys.version_info[0] == 2
  is_py26 = sys.version_info[:2] == (2, 6)
  is_py27 = sys.version_info[:2] == (2, 7)
  is_py3 = sys.version_info[0] == 3
  is_pypy = 'pypy' in sys.version.lower()
  is_windows = 'win32' in str(sys.platform).lower()
  
  
  if is_py2:
      bytes = str
      str = unicode
  elif is_py3:
      str = str
      bytes = bytes
  
  
  try:  # pragma: no cover
      # noinspection PyUnresolvedReferences,PyCompatibility
      from urllib.parse import urlsplit
  except ImportError:  # pragma: no cover
      # noinspection PyUnresolvedReferences,PyCompatibility
      from urlparse import urlsplit
  
  try:  # pragma: no cover
      # noinspection PyCompatibility
      from urllib.request import urlopen
  except ImportError:  # pragma: no cover
      # noinspection PyCompatibility
      from urllib2 import urlopen
  
  try:  # pragma: no cover
      from collections import OrderedDict
  except ImportError:  # pragma: no cover
      # Python 2.6 OrderedDict class, needed for headers, parameters, etc .###
      # <https://pypi.python.org/pypi/ordereddict/1.1>
      # noinspection PyCompatibility
      from UserDict import DictMixin
  
      # noinspection PyShadowingBuiltins
      class OrderedDict(dict, DictMixin):
          # Copyright (c) 2009 Raymond Hettinger
          #
          # Permission is hereby granted, free of charge, to any person
          # obtaining a copy of this software and associated documentation files
          # (the "Software"), to deal in the Software without restriction,
          # including without limitation the rights to use, copy, modify, merge,
          # publish, distribute, sublicense, and/or sell copies of the Software,
          # and to permit persons to whom the Software is furnished to do so,
          # subject to the following conditions:
          #
          #     The above copyright notice and this permission notice shall be
          #     included in all copies or substantial portions of the Software.
          #
          #     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
          #     EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
          #     OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
          #     NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
          #     HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
          #     WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
          #     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
          #     OTHER DEALINGS IN THE SOFTWARE.
          # noinspection PyMissingConstructor
          def __init__(self, *args, **kwds):
              if len(args) > 1:
                  raise TypeError('expected at most 1 arguments, got %d'
                                  % len(args))
              try:
                  self.__end
              except AttributeError:
                  self.clear()
              self.update(*args, **kwds)
  
          def clear(self):
              self.__end = end = []
              # noinspection PyUnusedLocal
              end += [None, end, end]     # sentinel node for doubly linked list
              self.__map = {}             # key --> [key, prev, next]
              dict.clear(self)
  
          def __setitem__(self, key, value):
              if key not in self:
                  end = self.__end
                  curr = end[1]
                  curr[2] = end[1] = self.__map[key] = [key, curr, end]
              dict.__setitem__(self, key, value)
  
          def __delitem__(self, key):
              dict.__delitem__(self, key)
              key, prev, next = self.__map.pop(key)
              prev[2] = next
              next[1] = prev
  
          def __iter__(self):
              end = self.__end
              curr = end[2]
              while curr is not end:
                  yield curr[0]
                  curr = curr[2]
  
          def __reversed__(self):
              end = self.__end
              curr = end[1]
              while curr is not end:
                  yield curr[0]
                  curr = curr[1]
  
          def popitem(self, last=True):
              if not self:
                  raise KeyError('dictionary is empty')
              if last:
                  key = reversed(self).next()
              else:
                  key = iter(self).next()
              value = self.pop(key)
              return key, value
  
          def __reduce__(self):
              items = [[k, self[k]] for k in self]
              tmp = self.__map, self.__end
              del self.__map, self.__end
              inst_dict = vars(self).copy()
              self.__map, self.__end = tmp
              if inst_dict:
                  return self.__class__, (items,), inst_dict
              return self.__class__, (items,)
  
          def keys(self):
              return list(self)
  
          setdefault = DictMixin.setdefault
          update = DictMixin.update
          pop = DictMixin.pop
          values = DictMixin.values
          items = DictMixin.items
          iterkeys = DictMixin.iterkeys
          itervalues = DictMixin.itervalues
          iteritems = DictMixin.iteritems
  
          def __repr__(self):
              if not self:
                  return '%s()' % (self.__class__.__name__,)
              return '%s(%r)' % (self.__class__.__name__, self.items())
  
          def copy(self):
              return self.__class__(self)
  
          # noinspection PyMethodOverriding
          @classmethod
          def fromkeys(cls, iterable, value=None):
              d = cls()
              for key in iterable:
                  d[key] = value
              return d
  
          def __eq__(self, other):
              if isinstance(other, OrderedDict):
                  if len(self) != len(other):
                      return False
                  for p, q in zip(self.items(), other.items()):
                      if p != q:
                          return False
                  return True
              return dict.__eq__(self, other)
  
          def __ne__(self, other):
              return not self == other
  