Ditch python2

.gitignore

@@ -2,6 +2,7 @@ doc
 version.py
 /python/bifrost/version/__init__.py
 *_generated.py
+*_typehints.py
 .log*.txt
 test/data/
 *.bin

configure

@@ -22310,7 +22310,19 @@ fi
 fi
        if test x${PYTHON} != xno
 then :
-  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON as ctypesgen" >&5
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if $PYTHON is version 3.6 or later" >&5
+printf %s "checking if $PYTHON is version 3.6 or later... " >&6; }
+              if ! ${PYTHON} -c "import sys; assert(sys.version_info >= (3,6,0))" 2>/dev/null
+then :
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
+printf "%s\n" "no" >&6; }
+                     { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: python module will not be built" >&5
+printf "%s\n" "$as_me: WARNING: python module will not be built" >&2;}
+else $as_nop
+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+printf "%s\n" "yes" >&6; }
+fi
+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON as ctypesgen" >&5
 printf %s "checking whether $PYTHON as ctypesgen... " >&6; }
               if ! ${PYTHON} -c "import ctypesgen" 2>/dev/null
 then :

configure.ac

@@ -232,7 +232,12 @@ AS_IF([test x$enable_python != xno],
               AS_IF([test x${PYTHON3} != xno],
                     [AC_SUBST([PYTHON], [$PYTHON3])])])
        AS_IF([test x${PYTHON} != xno],
-             [AC_MSG_CHECKING([whether $PYTHON as ctypesgen])
+             [AC_MSG_CHECKING([if $PYTHON is version 3.6 or later])
+              AS_IF([! ${PYTHON} -c "import sys; assert(sys.version_info >= (3,6,0))" 2>/dev/null],
+                    [AC_MSG_RESULT([no])
+                     AC_MSG_WARN([python module will not be built])],
+                    [AC_MSG_RESULT([yes])])
+              AC_MSG_CHECKING([whether $PYTHON as ctypesgen])
               AS_IF([! ${PYTHON} -c "import ctypesgen" 2>/dev/null],
                     [AC_MSG_RESULT([no])
                      AC_MSG_WARN([python module will not be built])],

python/Makefile.in

@@ -34,6 +34,11 @@ define run_ctypesgen
 	@SED@ -i.orig -e '/errcheck = ReturnString/s/^/#/' $@
 endef
 
+define run_typehinting
+        # Build the libbifrost typing hinting
+  @PYTHON@ -c 'from typehinting import build_typehinting; build_typehinting("$@")'
+endef
+
 ifeq "$(wildcard $(PSRDADA_HEADERS))" ""
 PSRDADA_PYTHON_BINDINGS_FILE =
 endif
@@ -46,6 +51,7 @@ $(PSRDADA_PYTHON_BINDINGS_FILE): $(PSRDADA_HEADERS)
 
 $(BIFROST_PYTHON_BINDINGS_FILE): $(INC_DIR)/bifrost/*.h
 	$(call run_ctypesgen,$(BIFROST_NAME),$(INC_DIR))
+	$(call run_typehinting,$(BIFROST_NAME),$(INC_DIR))
 
 build: bifrost/*.py Makefile $(BIFROST_PYTHON_VERSION_FILE) $(BIFROST_PYTHON_BINDINGS_FILE) $(PSRDADA_PYTHON_BINDINGS_FILE)
 	@PYTHON@ setup.py build @PYBUILDFLAGS@

python/bifrost/DataType.py

@@ -1,5 +1,5 @@
 
-# Copyright (c) 2016-2020, The Bifrost Authors. All rights reserved.
+# Copyright (c) 2016-2023, The Bifrost Authors. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
@@ -38,18 +38,12 @@
 cf32: 32+32-bit complex floating point
 """
 
-# Python2 compatibility
-from __future__ import division, absolute_import
-import sys
-string_types = (str,)
-if sys.version_info < (3,):
-    range = xrange
-    string_types = (basestring,)
-
-from bifrost.libbifrost import _bf
+from bifrost.libbifrost import _bf, _th
 from bifrost.libbifrost_generated import BF_FLOAT128_ENABLED
 import numpy as np
 
+from typing import Optional, Union
+
 from bifrost import telemetry
 telemetry.track_module()
 
@@ -114,7 +108,7 @@
     NUMPY_TYPEMAP['f'][128] = np.float128
     NUMPY_TYPEMAP['cf'][128] = np.complex256
 
-def is_vector_structure(dtype):
+def is_vector_structure(dtype: np.dtype) -> bool:
     if dtype.names is None:
         return False
     ndim = len(dtype.names)
@@ -125,17 +119,17 @@ def is_vector_structure(dtype):
 
 class DataType(object):
     # Note: Default of None results in default Numpy type (np.float)
-    def __init__(self, t=None):
-        if isinstance(t, string_types):
+    def __init__(self, t: Optional[Union[str,_th.BFdtype_enum,_bf.BFdtype,"DataType",np.dtype]]=None):
+        if isinstance(t, str):
             for i, char in enumerate(t):
                 if char.isdigit():
                     break
             self._kind =     t[:i]
             self._nbit = int(t[i:])
             self._veclen = 1 # TODO: Consider supporting this as part of string
-        elif isinstance(t, _bf.BFdtype): # Note: This is actually just a c_int
-            t = int(t)
-            self._nbit = t & BF_DTYPE_NBIT_BITS
+        elif isinstance(t, (_th.BFdtype_enum, _bf.BFdtype)): # Note: This is actually just a c_int
+            t = _th.BFdtype_enum(t).value
+            self._nbit = t & _bf.BF_DTYPE_NBIT_BITS
             is_complex = bool(t & _bf.BF_DTYPE_COMPLEX_BIT)
             self._kind = KINDMAP[t & _bf.BF_DTYPE_TYPE_BITS]
             if is_complex:
@@ -157,10 +151,10 @@ def __init__(self, t=None):
                 self._veclen = t.shape[0]
                 t = t.base
             else:
-                raise TypeError("Unsupported Numpy dtype: " + str(t))
+                raise TypeError(f"Unsupported Numpy dtype: {t}")
             self._nbit = t.itemsize * 8
             if t.kind not in set(['i', 'u', 'f', 'c', 'V', 'b']):
-                raise TypeError('Unsupported data type: %s' % str(t))
+                raise TypeError(f"Unsupported data type: {t}")
             if is_vector_structure(t): # Field structure representing vector
                 self._veclen = len(t.names)
                 t = t[0]
@@ -175,7 +169,7 @@ def __init__(self, t=None):
                 elif t in [cf16]:
                     self._kind = 'cf'
                 else:
-                    raise TypeError('Unsupported data type: %s' % str(t))
+                    raise TypeError(f"Unsupported data type: {t}")
             elif t.kind == 'b':
                 # Note: Represents booleans as uint8 inside Bifrost
                 self._kind = 'u'
@@ -185,10 +179,10 @@ def __eq__(self, other):
                 self._veclen == other._veclen)
     def __ne__(self, other):
         return not (self == other)
-    def as_BFdtype(self):
+    def as_BFdtype(self) -> _bf.BFdtype:
         base = TYPEMAP[self._kind][self._nbit]
         return base | ((self._veclen - 1) << _bf.BF_DTYPE_VECTOR_BIT0)
-    def as_numpy_dtype(self):
+    def as_numpy_dtype(self) -> np.dtype:
         base = np.dtype(NUMPY_TYPEMAP[self._kind][self._nbit])
         if self._veclen == 1:
             return base
@@ -201,25 +195,25 @@ def as_numpy_dtype(self):
             return np.dtype(','.join((str(base),)*self._veclen))
     def __str__(self):
         if self._veclen == 1:
-            return '%s%i' % (self._kind, self._nbit)
+            return f"{self._kind}{self._nbit}"
         else:
-            return '%s%i[%i]' % (self._kind, self._nbit, self._veclen)
+            return f"{self._kind}{self._nbit}[{self._veclen}]"
     @property
-    def is_complex(self):
+    def is_complex(self) -> bool:
         return self._kind[0] == 'c'
     @property
-    def is_real(self):
+    def is_real(self) -> bool:
         return not self.is_complex
     @property
-    def is_signed(self):
+    def is_signed(self) -> bool:
         return 'i' in self._kind or 'f' in self._kind
     @property
-    def is_floating_point(self):
+    def is_floating_point(self) -> bool:
         return 'f' in self._kind
     @property
-    def is_integer(self):
+    def is_integer(self) -> bool:
         return 'i' in self._kind or 'u' in self._kind
-    def as_floating_point(self):
+    def as_floating_point(self) -> "DataType":
         """Returns the smallest floating-point type that can represent all
         values that self can.
         """
@@ -228,32 +222,32 @@ def as_floating_point(self):
         kind = 'cf' if self.is_complex else 'f'
         nbit = 32 if self._nbit <= 24 else 64
         return DataType((kind, nbit, self._veclen))
-    def as_integer(self, nbit=None):
+    def as_integer(self, nbit: int=None) -> "DataType":
         if nbit is None:
             nbit = self._nbit
         kind = self._kind
         if self.is_floating_point:
             kind = kind.replace('f', 'i')
         return DataType((kind, nbit, self._veclen))
-    def as_real(self):
+    def as_real(self) -> "DataType":
         if self.is_complex:
             return DataType((self._kind[1:], self._nbit, self._veclen))
         else:
             return self
-    def as_complex(self):
+    def as_complex(self) -> "DataType":
         if self.is_complex:
             return self
         else:
             return DataType(('c' + self._kind, self._nbit, self._veclen))
-    def as_nbit(self, nbit):
+    def as_nbit(self, nbit: int) -> "DataType":
         return DataType((self._kind, nbit, self._veclen))
-    def as_vector(self, veclen):
+    def as_vector(self, veclen: int) -> "DataType":
         return DataType((self._kind, self._nbit, veclen))
     @property
-    def itemsize_bits(self):
+    def itemsize_bits(self) -> int:
         return self._nbit * (1 + self.is_complex) * self._veclen
     @property
-    def itemsize(self):
+    def itemsize(self) -> int:
         item_nbit = self.itemsize_bits
         if item_nbit < 8:
             raise ValueError('itemsize is undefined when nbit < 8')