python/samba/compat.py

   1 # module which helps with porting to Python 3
   2 #
   3 # Copyright (C) Lumir Balhar <lbalhar@redhat.com> 2017
   4 #
   5 # This program is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 3 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 """module which helps with porting to Python 3"""
  19
  20 import sys
  21
  22 PY3 = sys.version_info[0] == 3
  23
  24 if PY3:
  25     # Sometimes in PY3 we have variables whose content can be 'bytes' or
  26     # 'str' and we can't be sure which. Generally this is because the
  27     # code variable can be initialised (or reassigned) a value from different
  28     # api(s) or functions depending on complex conditions or logic. Or another
  29     # common case is in PY2 the variable is 'type <str>' and in PY3 it is
  30     # 'class <str>' and the function to use e.g. b64encode requires 'bytes'
  31     # in PY3. In such cases it would be nice to avoid excessive testing in
  32     # the client code. Calling such a helper function should be avoided
  33     # if possible but sometimes this just isn't possible.
  34     # If a 'str' object is passed in it is encoded using 'utf8' or if 'bytes'
  35     # is passed in it is returned unchanged.
  36     # Using this function is PY2/PY3 code should ensure in most cases
  37     # the PY2 code runs unchanged in PY2 whereas the code in PY3 possibly
  38     # encodes the variable (see PY2 implementation of this function below)
  39     def get_bytes(bytesorstring):
  40         tmp = bytesorstring
  41         if isinstance(bytesorstring, str):
  42             tmp = bytesorstring.encode('utf8')
  43         elif not isinstance(bytesorstring, bytes):
  44             raise ValueError('Expected byte or string for %s:%s' % (type(bytesorstring), bytesorstring))
  45         return tmp
  46
  47     # helper function to get a string from a variable that maybe 'str' or
  48     # 'bytes' if 'bytes' then it is decoded using 'utf8'. If 'str' is passed
  49     # it is returned unchanged
  50     # Using this function is PY2/PY3 code should ensure in most cases
  51     # the PY2 code runs unchanged in PY2 whereas the code in PY3 possibly
  52     # decodes the variable (see PY2 implementation of this function below)
  53     def get_string(bytesorstring):
  54         tmp = bytesorstring
  55         if isinstance(bytesorstring, bytes):
  56             tmp = bytesorstring.decode('utf8')
  57         elif not isinstance(bytesorstring, str):
  58             raise ValueError('Expected byte of string for %s:%s' % (type(bytesorstring), bytesorstring))
  59         return tmp
  60
  61     def cmp_fn(x, y):
  62         """
  63         Replacement for built-in function cmp that was removed in Python 3
  64
  65         Compare the two objects x and y and return an integer according to
  66         the outcome. The return value is negative if x < y, zero if x == y
  67         and strictly positive if x > y.
  68         """
  69
  70         return (x > y) - (x < y)
  71     # compat functions
  72     from functools import cmp_to_key as cmp_to_key_fn
  73
  74     # compat types
  75     integer_types = int,
  76     string_types = str
  77     text_type = str
  78     binary_type = bytes
  79
  80     # alias
  81     import io
  82     StringIO = io.StringIO
  83     def ConfigParser(defaults=None, dict_type=dict, allow_no_value=False):
  84         from configparser import ConfigParser
  85         return ConfigParser(defaults, dict_type, allow_no_value, interpolation=None)
  86 else:
  87     # Helper function to return bytes.
  88     # if 'unicode' is passed in then it is decoded using 'utf8' and
  89     # the result returned. If 'str' is passed then it is returned unchanged.
  90     # Using this function is PY2/PY3 code should ensure in most cases
  91     # the PY2 code runs unchanged in PY2 whereas the code in PY3 possibly
  92     # encodes the variable (see PY3 implementation of this function above)
  93     def get_bytes(bytesorstring):
  94         tmp = bytesorstring
  95         if isinstance(bytesorstring, unicode):
  96             tmp = bytesorstring.encode('utf8')
  97         elif not isinstance(bytesorstring, str):
  98             raise ValueError('Expected string for %s:%s' % (type(bytesorstring), bytesorstring))
  99         return tmp
 100
 101     # Helper function to return string.
 102     # if 'str' or 'unicode' passed in they are returned unchanged
 103     # otherwise an exception is generated
 104     # Using this function is PY2/PY3 code should ensure in most cases
 105     # the PY2 code runs unchanged in PY2 whereas the code in PY3 possibly
 106     # decodes the variable (see PY3 implementation of this function above)
 107     def get_string(bytesorstring):
 108         tmp = bytesorstring
 109         if not(isinstance(bytesorstring, str) or isinstance(bytesorstring, unicode)):
 110             raise ValueError('Expected str or unicode for %s:%s' % (type(bytesorstring), bytesorstring))
 111         return tmp
 112
 113
 114     if sys.version_info < (2, 7):
 115         def cmp_to_key_fn(mycmp):
 116
 117             """Convert a cmp= function into a key= function"""
 118             class K(object):
 119                 __slots__ = ['obj']
 120
 121                 def __init__(self, obj, *args):
 122                     self.obj = obj
 123
 124                 def __lt__(self, other):
 125                     return mycmp(self.obj, other.obj) < 0
 126
 127                 def __gt__(self, other):
 128                     return mycmp(self.obj, other.obj) > 0
 129
 130                 def __eq__(self, other):
 131                     return mycmp(self.obj, other.obj) == 0
 132
 133                 def __le__(self, other):
 134                     return mycmp(self.obj, other.obj) <= 0
 135
 136                 def __ge__(self, other):
 137                     return mycmp(self.obj, other.obj) >= 0
 138
 139                 def __ne__(self, other):
 140                     return mycmp(self.obj, other.obj) != 0
 141
 142                 def __hash__(self):
 143                     raise TypeError('hash not implemented')
 144             return K
 145     else:
 146         from functools import cmp_to_key as cmp_to_key_fn
 147
 148     # compat types
 149     integer_types = (int, long)
 150     string_types = basestring
 151     text_type = unicode
 152     binary_type = str
 153
 154     # alias
 155     import cStringIO
 156     StringIO = cStringIO.StringIO
 157     from ConfigParser import ConfigParser
 158     cmp_fn = cmp