Apply ruff/pyupgrade rule UP036

UP036 Version block is outdated for minimum Python version

Lots of manual fixes here, in order to discard Python 2 aliases.

Co-authored-by: Matti Picus <[email protected]>

Author: DimitriPapadopoulos

src/c/test_c.py

@@ -3,12 +3,6 @@
 from .error import CDefError
 from . import model
 
-try:
-    basestring
-except NameError:
-    # Python 3.x
-    basestring = str
-
 _unspecified = object()
 
 
@@ -111,7 +105,7 @@ def embedding_api(self, csource, packed=False, pack=None):
 
     def _cdef(self, csource, override=False, **options):
         if not isinstance(csource, str):    # unicode, on Python 2
-            if not isinstance(csource, basestring):
+            if not isinstance(csource, str):
                 raise TypeError("cdef() argument must be a string")
             csource = csource.encode('ascii')
         with self._lock:
@@ -134,7 +128,7 @@ def dlopen(self, name, flags=0):
         linked to a particular library, just like C headers; in the
         library we only look for the actual (untyped) symbols.
         """
-        if not (isinstance(name, basestring) or
+        if not (isinstance(name, str) or
                 name is None or
                 isinstance(name, self.CData)):
             raise TypeError("dlopen(name): name must be a file name, None, "
@@ -189,7 +183,7 @@ def typeof(self, cdecl):
         corresponding <ctype> object.
         It can also be used on 'cdata' instance to get its C type.
         """
-        if isinstance(cdecl, basestring):
+        if isinstance(cdecl, str):
             return self._typeof(cdecl)
         if isinstance(cdecl, self.CData):
             return self._backend.typeof(cdecl)
@@ -207,7 +201,7 @@ def sizeof(self, cdecl):
         """Return the size in bytes of the argument.  It can be a
         string naming a C type, or a 'cdata' instance.
         """
-        if isinstance(cdecl, basestring):
+        if isinstance(cdecl, str):
             BType = self._typeof(cdecl)
             return self._backend.sizeof(BType)
         else:
@@ -217,7 +211,7 @@ def alignof(self, cdecl):
         """Return the natural alignment size in bytes of the C type
         given as a string.
         """
-        if isinstance(cdecl, basestring):
+        if isinstance(cdecl, str):
             cdecl = self._typeof(cdecl)
         return self._backend.alignof(cdecl)
 
@@ -228,7 +222,7 @@ def offsetof(self, cdecl, *fields_or_indexes):
         You can also give numeric values which correspond to array
         items, in case of an array type.
         """
-        if isinstance(cdecl, basestring):
+        if isinstance(cdecl, str):
             cdecl = self._typeof(cdecl)
         return self._typeoffsetof(cdecl, *fields_or_indexes)[1]
 
@@ -255,7 +249,7 @@ def new(self, cdecl, init=None):
         about that when copying the pointer to the memory somewhere
         else, e.g. into another structure.
         """
-        if isinstance(cdecl, basestring):
+        if isinstance(cdecl, str):
             cdecl = self._typeof(cdecl)
         return self._backend.newp(cdecl, init)
 
@@ -278,7 +272,7 @@ def new_allocator(self, alloc=None, free=None,
         allocator = compiled_ffi.new_allocator(alloc, free,
                                                should_clear_after_alloc)
         def allocate(cdecl, init=None):
-            if isinstance(cdecl, basestring):
+            if isinstance(cdecl, str):
                 cdecl = self._typeof(cdecl)
             return allocator(cdecl, init)
         return allocate
@@ -288,7 +282,7 @@ def cast(self, cdecl, source):
         type initialized with the given 'source'.  The source is
         casted between integers or pointers of any type.
         """
-        if isinstance(cdecl, basestring):
+        if isinstance(cdecl, str):
             cdecl = self._typeof(cdecl)
         return self._backend.cast(cdecl, source)
 
@@ -353,7 +347,7 @@ def from_buffer(self, cdecl, python_buffer=_unspecified,
         """
         if python_buffer is _unspecified:
             cdecl, python_buffer = self.BCharA, cdecl
-        elif isinstance(cdecl, basestring):
+        elif isinstance(cdecl, str):
             cdecl = self._typeof(cdecl)
         return self._backend.from_buffer(cdecl, python_buffer,
                                          require_writable)
@@ -388,7 +382,7 @@ def callback_decorator_wrap(python_callable):
                                 "is not callable")
             return self._backend.callback(cdecl, python_callable,
                                           error, onerror)
-        if isinstance(cdecl, basestring):
+        if isinstance(cdecl, str):
             cdecl = self._typeof(cdecl, consider_function_as_funcptr=True)
         if python_callable is None:
             return callback_decorator_wrap                # decorator mode
@@ -401,7 +395,7 @@ def getctype(self, cdecl, replace_with=''):
         extra text to append (or insert for more complicated C types), like
         a variable name, or '*' to get actually the C type 'pointer-to-cdecl'.
         """
-        if isinstance(cdecl, basestring):
+        if isinstance(cdecl, str):
             cdecl = self._typeof(cdecl)
         replace_with = replace_with.strip()
         if (replace_with.startswith('*')
@@ -596,10 +590,7 @@ def ensure(key, value):
                 # we need 'libpypy-c.{so,dylib}', which should be by
                 # default located in 'sys.prefix/bin' for installed
                 # systems.
-                if sys.version_info < (3,):
-                    pythonlib = "pypy-c"
-                else:
-                    pythonlib = "pypy3-c"
+                pythonlib = "pypy3-c"
                 if hasattr(sys, 'prefix'):
                     ensure('library_dirs', os.path.join(sys.prefix, 'bin'))
             # On uninstalled pypy's, the libpypy-c is typically found in
@@ -632,7 +623,7 @@ def set_source(self, module_name, source, source_extension='.c', **kwds):
         if hasattr(self, '_assigned_source'):
             raise ValueError("set_source() cannot be called several times "
                              "per ffi object")
-        if not isinstance(module_name, basestring):
+        if not isinstance(module_name, str):
             raise TypeError("'module_name' must be a string")
         if os.sep in module_name or (os.altsep and os.altsep in module_name):
             raise ValueError("'module_name' must not contain '/': use a dotted "
@@ -798,7 +789,7 @@ def list_types(self):
 
 def _load_backend_lib(backend, name, flags):
     import os
-    if not isinstance(name, basestring):
+    if not isinstance(name, str):
         if sys.platform != "win32" or name is not None:
             return backend.load_library(name, flags)
         name = "c"    # Windows: load_library(None) fails, but this works
@@ -934,7 +925,7 @@ def __cffi_close__(self):
             backendlib.close_lib()
             self.__dict__.clear()
     #
-    if isinstance(libname, basestring):
+    if isinstance(libname, str):
         try:
             if not isinstance(libname, str):    # unicode, on Python 2
                 libname = libname.encode('utf-8')

src/cffi/api.py

@@ -1,14 +1,6 @@
 import ctypes, ctypes.util, operator, sys
 from . import model
 
-if sys.version_info < (3,):
-    bytechr = chr
-else:
-    unicode = str
-    long = int
-    xrange = range
-    bytechr = lambda num: bytes([num])
-
 class CTypesType(type):
     pass
 
@@ -161,7 +153,7 @@ def _newp(cls, init):
         return cls(init)
 
     def __iter__(self):
-        for i in xrange(len(self)):
+        for i in range(len(self)):
             yield self[i]
 
     def _get_own_repr(self):
@@ -183,7 +175,7 @@ def _cast_from(cls, source):
             address = 0
         elif isinstance(source, CTypesData):
             address = source._cast_to_integer()
-        elif isinstance(source, (int, long)):
+        elif isinstance(source, int):
             address = source
         else:
             raise TypeError("bad type for cast to %r: %r" %
@@ -399,7 +391,7 @@ def __int__(self):
             if kind == 'bool':
                 @classmethod
                 def _cast_from(cls, source):
-                    if not isinstance(source, (int, long, float)):
+                    if not isinstance(source, (int, float)):
                         source = _cast_source_to_int(source)
                     return cls(bool(source))
                 def __int__(self):
@@ -409,7 +401,7 @@ def __int__(self):
                 @classmethod
                 def _cast_from(cls, source):
                     source = _cast_source_to_int(source)
-                    source = bytechr(source & 0xFF)
+                    source = bytes([source & 0xFF])
                     return cls(source)
                 def __int__(self):
                     return ord(self._value)
@@ -438,7 +430,7 @@ def __float__(self):
             if kind == 'int' or kind == 'byte' or kind == 'bool':
                 @staticmethod
                 def _to_ctypes(x):
-                    if not isinstance(x, (int, long)):
+                    if not isinstance(x, int):
                         if isinstance(x, CTypesData):
                             x = int(x)
                         else:
@@ -471,7 +463,7 @@ def __nonzero__(self):
             if kind == 'float':
                 @staticmethod
                 def _to_ctypes(x):
-                    if not isinstance(x, (int, long, float, CTypesData)):
+                    if not isinstance(x, (int, float, CTypesData)):
                         raise TypeError("float expected, got %s" %
                                         type(x).__name__)
                     return ctype(x).value
@@ -535,14 +527,14 @@ def __init__(self, init):
                 self._own = True
 
             def __add__(self, other):
-                if isinstance(other, (int, long)):
+                if isinstance(other, int):
                     return self._new_pointer_at(self._address +
                                                 other * self._bitem_size)
                 else:
                     return NotImplemented
 
             def __sub__(self, other):
-                if isinstance(other, (int, long)):
+                if isinstance(other, int):
                     return self._new_pointer_at(self._address -
                                                 other * self._bitem_size)
                 elif type(self) is type(other):
@@ -617,7 +609,7 @@ class CTypesArray(CTypesGenericArray):
 
             def __init__(self, init):
                 if length is None:
-                    if isinstance(init, (int, long)):
+                    if isinstance(init, int):
                         len1 = init
                         init = None
                     elif kind == 'char' and isinstance(init, bytes):
@@ -696,7 +688,7 @@ def _arg_to_ctypes(value):
                 return CTypesPtr._arg_to_ctypes(value)
 
             def __add__(self, other):
-                if isinstance(other, (int, long)):
+                if isinstance(other, long):
                     return CTypesPtr._new_pointer_at(
                         ctypes.addressof(self._blob) +
                         other * ctypes.sizeof(BItem._ctype))
@@ -776,7 +768,7 @@ def initialize(blob, init):
                                     "only one supported (use a dict if needed)"
                                      % (len(init),))
             if not isinstance(init, dict):
-                if isinstance(init, (bytes, unicode)):
+                if isinstance(init, (bytes, str)):
                     raise TypeError("union initializer: got a str")
                 init = tuple(init)
                 if len(init) > len(fnames):
@@ -1061,7 +1053,7 @@ def typeoffsetof(self, BType, fieldname, num=0):
             if BField is Ellipsis:
                 raise TypeError("not supported for bitfields")
             return (BField, BType._offsetof(fieldname))
-        elif isinstance(fieldname, (int, long)):
+        elif isinstance(fieldname, int):
             if issubclass(BType, CTypesGenericArray):
                 BType = BType._CTPtr
             if not issubclass(BType, CTypesGenericPtr):

src/cffi/backend_ctypes.py

@@ -8,10 +8,7 @@
 import weakref, re, sys
 
 try:
-    if sys.version_info < (3,):
-        import thread as _thread
-    else:
-        import _thread
+    import _thread
     lock = _thread.allocate_lock()
 except ImportError:
     lock = None

src/cffi/cparser.py

@@ -1,15 +1,9 @@
 import sys
 
-if sys.version_info < (3,):
-    try:
-        from thread import allocate_lock
-    except ImportError:
-        from dummy_thread import allocate_lock
-else:
-    try:
-        from _thread import allocate_lock
-    except ImportError:
-        from _dummy_thread import allocate_lock
+try:
+    from _thread import allocate_lock
+except ImportError:
+    from _dummy_thread import allocate_lock
 
 
 ##import sys

src/cffi/lock.py

@@ -1316,12 +1316,8 @@ def _print_string_literal_in_array(self, s):
         else:
             s.decode('utf-8')           # got bytes, check for valid utf-8
         for line in s.splitlines(True):
-            comment = line
-            if type('//') is bytes:     # python2
-                line = map(ord, line)   #     make a list of integers
-            else:                       # python3
-                # type(line) is bytes, which enumerates like a list of integers
-                comment = ascii(comment)[1:-1]
+            # type(line) is bytes, which enumerates like a list of integers
+            comment = ascii(line)[1:-1]
             prnt(('// ' + comment).rstrip())
             printed_line = ''
             for c in line:
@@ -1406,15 +1402,6 @@ def _emit_bytecode_EnumType(self, tp, index):
         self.cffi_types[index] = CffiOp(OP_ENUM, enum_index)
 
 
-if sys.version_info >= (3,):
-    NativeIO = io.StringIO
-else:
-    class NativeIO(io.BytesIO):
-        def write(self, s):
-            if isinstance(s, unicode):
-                s = s.encode('ascii')
-            super().write(s)
-
 def _is_file_like(maybefile):
     # compare to xml.etree.ElementTree._get_writer
     return hasattr(maybefile, 'write')
@@ -1429,7 +1416,7 @@ def _make_c_or_py_source(ffi, module_name, preamble, target_file, verbose):
     if _is_file_like(target_file):
         recompiler.write_source_to_f(target_file, preamble)
         return True
-    f = NativeIO()
+    f = io.StringIO()
     recompiler.write_source_to_f(f, preamble)
     output = f.getvalue()
     try:

src/cffi/recompiler.py

@@ -55,12 +55,8 @@ def write_source_to_f(self):
         # 'export_symbols', so instead of fighting it, just give up and
         # give it one
         if sys.platform == 'win32':
-            if sys.version_info >= (3,):
-                prefix = 'PyInit_'
-            else:
-                prefix = 'init'
             modname = self.verifier.get_module_name()
-            prnt("void %s%s(void) { }\n" % (prefix, modname))
+            prnt(f"void PyInit_{modname}(void) { }\n")
 
     def load_library(self, flags=0):
         # import it with the CFFI backend
@@ -496,10 +492,7 @@ def _load_known_int_constant(self, module, funcname):
         function = module.load_function(BFunc, funcname)
         p = self.ffi.new(BType, 256)
         if function(p) < 0:
-            error = self.ffi.string(p)
-            if sys.version_info >= (3,):
-                error = str(error, 'utf-8')
-            raise VerificationError(error)
+            raise VerificationError(self.ffi.string(p))
 
     def _enum_funcname(self, prefix, name):
         # "$enum_$1" => "___D_enum____D_1"