Remove (most) Python 2 support from C++ code (pytorch#35614)

Summary:
Pull Request resolved: pytorch#35614

Python 2 has reached end-of-life and is no longer supported by PyTorch.
Now we can clean up a lot of cruft that we put in place to support it.
These changes were all done manually, and I skipped anything that seemed
like it would take more than a few seconds, so I think it makes sense to
review it manually as well.

Test Plan: CI

Differential Revision: D20842876

Pulled By: dreiss

fbshipit-source-id: 18abf0d324ed2185ec6d27c864e935d856dcc6ad

Author: dreiss

tools/autograd/templates/python_nn_functions.cpp

@@ -66,10 +66,6 @@ static PyMethodDef nn_functions[] = {
 static PyObject* THPNNVariableFunctionsModule = NULL;
 
 void initNNFunctions(PyObject* module) {
-#if PY_MAJOR_VERSION == 2
-  PyObject* nn = Py_InitModule("torch._C._nn", nn_functions);
-  Py_XINCREF(nn);  // Py_InitModule returns "borrowed" reference
-#else
   static struct PyModuleDef def = {
      PyModuleDef_HEAD_INIT,
      "torch._C._nn",
@@ -78,7 +74,6 @@ void initNNFunctions(PyObject* module) {
      nn_functions
   };
   PyObject* nn = PyModule_Create(&def);
-#endif
   THPNNVariableFunctionsModule = nn;
   if (!nn) {
     throw python_error();

torch/csrc/Dtype.h

@@ -21,9 +21,6 @@ inline bool THPDtype_Check(PyObject *obj) {
 inline bool THPPythonScalarType_Check(PyObject *obj) {
   return obj == (PyObject*)(&PyFloat_Type) ||
     obj == (PyObject*)(&PyBool_Type) ||
-#if PY_MAJOR_VERSION == 2
-    obj == (PyObject*)(&PyInt_Type) ||
-#endif
     obj == (PyObject*)(&PyLong_Type);
 }
 

torch/csrc/Module.cpp

@@ -650,9 +650,6 @@ PyObject* initModule() {
 #endif
 #endif
 
-#if PY_MAJOR_VERSION == 2
-  ASSERT_TRUE(module = Py_InitModule("torch._C", methods.data()));
-#else
   static struct PyModuleDef torchmodule = {
      PyModuleDef_HEAD_INIT,
      "torch._C",
@@ -661,7 +658,6 @@ PyObject* initModule() {
      methods.data()
   };
   ASSERT_TRUE(module = PyModule_Create(&torchmodule));
-#endif
   ASSERT_TRUE(THPWrapper_init(module));
   ASSERT_TRUE(THPGenerator_init(module));
   ASSERT_TRUE(THPException_init(module));

torch/csrc/Size.cpp

@@ -109,9 +109,6 @@ static PyObject* wrap_tuple_fn(Args ... args)
 namespace {
   auto sq_concat = PyTuple_Type.tp_as_sequence->sq_concat;
   auto sq_repeat = PyTuple_Type.tp_as_sequence->sq_repeat;
-  #if PY_MAJOR_VERSION == 2
-  auto sq_slice = PyTuple_Type.tp_as_sequence->sq_slice;
-  #endif
   binaryfunc mp_subscript = PyTuple_Type.tp_as_mapping->mp_subscript;
 }
 
@@ -121,11 +118,7 @@ static PySequenceMethods THPSize_as_sequence = {
   wrap_tuple_fn<decltype(&sq_concat), &sq_concat>,
   wrap_tuple_fn<decltype(&sq_repeat), &sq_repeat>,
   nullptr,                                          /* sq_item */
-#if PY_MAJOR_VERSION == 2
-  wrap_tuple_fn<decltype(&sq_slice), &sq_slice>,
-#else
   nullptr,                                          /* sq_slice */
-#endif
   nullptr,                                          /* sq_ass_item */
   nullptr,                                          /* sq_ass_slice */
   nullptr                                           /* sq_contains */

torch/csrc/api/include/torch/python.h

@@ -67,12 +67,7 @@ void bind_cpp_module_wrapper(
 
   // `type()` always needs a `str`, but pybind11's `str()` method always creates
   // a `unicode` object.
-#if PY_MAJOR_VERSION < 3
-  py::object name_str =
-      py::reinterpret_steal<py::object>(PyString_FromString(name));
-#else
   py::object name_str = py::str(name);
-#endif
 
   // Dynamically create the subclass of `ModuleWrapper`, which is a subclass of
   // `torch.nn.Module`, and will delegate all calls to the C++ module we're

torch/csrc/dl.c

@@ -7,42 +7,25 @@ static PyMethodDef TorchDlMethods[] = {
   {NULL, NULL, 0, NULL}
 };
 
-#if PY_MAJOR_VERSION != 2
 static struct PyModuleDef torchdlmodule = {
    PyModuleDef_HEAD_INIT,
    "torch._dl",
    NULL,
    -1,
    TorchDlMethods
 };
-#endif
 
-#if PY_MAJOR_VERSION == 2
-PyMODINIT_FUNC init_dl(void)
-#else
 PyMODINIT_FUNC PyInit__dl(void)
-#endif
 {
 
-#if PY_MAJOR_VERSION == 2
-#define ASSERT_TRUE(cmd) if (!(cmd)) {PyErr_SetString(PyExc_ImportError, "initialization error"); return;}
-#else
 #define ASSERT_TRUE(cmd) if (!(cmd)) return NULL
-#endif
 
-#if PY_MAJOR_VERSION == 2
-  ASSERT_TRUE(module = Py_InitModule("torch._dl", TorchDlMethods));
-#else
   ASSERT_TRUE(module = PyModule_Create(&torchdlmodule));
-#endif
   ASSERT_TRUE(PyModule_AddIntConstant(module, "RTLD_GLOBAL", (int64_t) RTLD_GLOBAL) == 0);
   ASSERT_TRUE(PyModule_AddIntConstant(module, "RTLD_NOW", (int64_t) RTLD_NOW) == 0);
   ASSERT_TRUE(PyModule_AddIntConstant(module, "RTLD_LAZY", (int64_t) RTLD_LAZY) == 0);
 
-#if PY_MAJOR_VERSION == 2
-#else
   return module;
-#endif
 
 #undef ASSERT_TRUE
 }

torch/csrc/jit/python/init.cpp

@@ -673,12 +673,8 @@ void initJITBindings(PyObject* module) {
     }
 
     THPObjectPtr getMemview(void* buf, size_t n) const {
-#if PY_MAJOR_VERSION >= 3
       THPObjectPtr memview(PyMemoryView_FromMemory(
           reinterpret_cast<char*>(buf), n, PyBUF_WRITE));
-#else
-      THPObjectPtr memview(PyBuffer_FromReadWriteMemory(buf, n));
-#endif
       if (!memview) {
         throw python_error();
       }

torch/csrc/jit/python/python_sugared_value.cpp

@@ -701,9 +701,7 @@ std::shared_ptr<SugaredValue> toSugaredValue(
     return SpecialFormValue::create(prim::annotate);
 #ifdef USE_DISTRIBUTED
   } else if (
-      // RPC module is only avaialble for Python3
-      // when build flag "USE_DISTRIBUTED" is on.
-      !py::module::import("torch._six").attr("PY2").cast<bool>() &&
+      // RPC module is only avaialble  when build flag "USE_DISTRIBUTED" is on.
       obj.ptr() ==
           py::module::import("torch.distributed.rpc").attr("rpc_async").ptr()) {
     return SpecialFormValue::create(prim::rpc_async);

torch/csrc/python_headers.h

@@ -1,6 +1,7 @@
 #pragma once
 
 // workaround for Python 2 issue: https://bugs.python.org/issue17120
+// NOTE: It looks like this affects Python 3 as well.
 #pragma push_macro("_XOPEN_SOURCE")
 #pragma push_macro("_POSIX_C_SOURCE")
 #undef _XOPEN_SOURCE

torch/csrc/serialization.cpp

@@ -61,14 +61,8 @@ static inline ssize_t doPartialPythonReadBuffered(PyObject* fildes, void* buf, s
   THPObjectPtr r(PyObject_CallMethod(fildes, "read", "i", nbytes));
   if (!r) throw python_error();
 
-  // read output is String (Python 2) / Bytes (Python 3)
-#if PY_MAJOR_VERSION >= 3
   auto size = PyBytes_GET_SIZE(r.get());
   const void* py_buf = PyBytes_AsString(r.get());
-#else
-  auto size = PyString_GET_SIZE(r.get());
-  const void* py_buf = PyString_AsString(r.get());
-#endif
 
   // we read EOF
   if (size == 0) {
@@ -83,13 +77,9 @@ static inline ssize_t doPartialPythonReadBuffered(PyObject* fildes, void* buf, s
 
 // Either does fildes.readinto(buf) or fildes.write(buf)
 static inline ssize_t doPartialPythonIO(PyObject* fildes, void* buf, size_t nbytes, bool is_read) {
-#if PY_MAJOR_VERSION >= 3
   auto rw_flag = is_read ? PyBUF_WRITE : PyBUF_READ;
   THPObjectPtr memview(PyMemoryView_FromMemory(
       reinterpret_cast<char*>(buf), nbytes, rw_flag));
-#else
-  THPObjectPtr memview(PyBuffer_FromReadWriteMemory(buf, nbytes));
-#endif
   if (!memview) throw python_error();
 
   char* method = "write";

torch/csrc/stub.cpp

@@ -5,14 +5,7 @@ __declspec(dllimport)
 #endif
 extern PyObject* initModule();
 
-#if PY_MAJOR_VERSION == 2
-PyMODINIT_FUNC init_C()
-{
-  initModule();
-}
-#else
 PyMODINIT_FUNC PyInit__C()
 {
   return initModule();
 }
-#endif

torch/csrc/utils.h

@@ -24,24 +24,6 @@
 #define THP_EXPECT(x, y) (x)
 #endif
 
-#if PY_MAJOR_VERSION == 2
-#define THPUtils_checkReal_FLOAT(object)                                       \
-    (PyFloat_Check(object) || PyLong_Check(object) || PyInt_Check(object))
-
-#define THPUtils_unpackReal_FLOAT(object)                                      \
-    (PyFloat_Check(object) ? PyFloat_AsDouble(object) :                        \
-    PyLong_Check(object) ? PyLong_AsLongLong(object) :                         \
-    PyInt_Check(object) ? PyInt_AsLong(object) :                               \
-    (throw std::runtime_error("Could not parse real"), 0))
-
-#define THPUtils_checkReal_INT(object)                                         \
-    (PyLong_Check(object) || PyInt_Check(object))
-
-#define THPUtils_unpackReal_INT(object)                                        \
-    (PyLong_Check(object) ? PyLong_AsLongLong(object) :                        \
-    PyInt_Check(object) ? PyInt_AsLong(object) :                               \
-    (throw std::runtime_error("Could not parse real"), 0))
-#else /* PY_MAJOR_VERSION == 2 */
 #define THPUtils_checkReal_FLOAT(object)                                       \
     (PyFloat_Check(object) || PyLong_Check(object))
 
@@ -56,7 +38,6 @@
 #define THPUtils_unpackReal_INT(object)                                        \
     (PyLong_Check(object) ? PyLong_AsLongLong(object) :                        \
     (throw std::runtime_error("Could not parse real"), 0))
-#endif
 
 #define THPUtils_unpackReal_BOOL(object)                                       \
     (PyBool_Check(object) ? object :                                           \
@@ -76,7 +57,6 @@
     PyComplex_Check(object) || PyFloat_Check(object) || PyLong_Check(object) || PyInt_Check(object)
 
 #define THPUtils_newReal_FLOAT(value) PyFloat_FromDouble(value)
-// TODO: handle int overflows for py2
 #define THPUtils_newReal_INT(value) PyInt_FromLong(value)
 
 #define THPUtils_newReal_BOOL(value) PyBool_FromLong(value)

torch/csrc/utils/python_arg_parser.h

@@ -355,11 +355,7 @@ inline at::ScalarType PythonArgs::scalartype(int i) {
   if (obj == (PyObject*)&PyBool_Type) {
     return at::ScalarType::Bool;
   }
-  if (obj == (PyObject*)&PyLong_Type
-#if PY_MAJOR_VERSION == 2
-      || obj == (PyObject*)&PyInt_Type
-#endif
-  ) {
+  if (obj == (PyObject*)&PyLong_Type) {
     return at::ScalarType::Long;
   }
   return reinterpret_cast<THPDtype*>(obj)->scalar_type;
@@ -624,10 +620,6 @@ static bool _is_basic_python_type(PyTypeObject *tp)
     tp == &PyUnicode_Type ||
     tp == &PyBytes_Type ||
 
-#if PY_MAJOR_VERSION == 2
-    tp == &PyString_Type ||
-#endif
-
     /* other builtins */
     tp == &PySlice_Type ||
     tp == Py_TYPE(Py_None) ||

torch/csrc/utils/python_numbers.h

@@ -12,31 +12,14 @@
 const int64_t DOUBLE_INT_MAX = 9007199254740992;
 
 inline PyObject* THPUtils_packInt64(int64_t value) {
-#if PY_MAJOR_VERSION == 2
-  if (sizeof(long) == sizeof(int64_t)) {
-    return PyInt_FromLong(static_cast<long>(value));
-  } else if (value <= INT32_MAX && value >= INT32_MIN) {
-    return PyInt_FromLong(static_cast<long>(value));
-  }
-#endif
   return PyLong_FromLongLong(value);
 }
 
 inline PyObject* THPUtils_packUInt64(uint64_t value) {
-#if PY_MAJOR_VERSION == 2
-  if (value <= INT32_MAX) {
-    return PyInt_FromLong(static_cast<long>(value));
-  }
-#endif
   return PyLong_FromUnsignedLongLong(value);
 }
 
 inline PyObject* THPUtils_packDoubleAsInt(double value) {
-#if PY_MAJOR_VERSION == 2
-  if (value <= INT32_MAX && value >= INT32_MIN) {
-    return PyInt_FromLong(static_cast<long>(value));
-  }
-#endif
   return PyLong_FromDouble(value);
 }
 
@@ -47,11 +30,7 @@ inline bool THPUtils_checkLong(PyObject* obj) {
   }
 #endif
 
-#if PY_MAJOR_VERSION == 2
-  return (PyLong_Check(obj) || PyInt_Check(obj)) && !PyBool_Check(obj);
-#else
   return PyLong_Check(obj) && !PyBool_Check(obj);
-#endif
 }
 
 inline int64_t THPUtils_unpackLong(PyObject* obj) {
@@ -111,11 +90,7 @@ inline bool THPUtils_checkDouble(PyObject* obj) {
     return true;
   }
 #endif
-#if PY_MAJOR_VERSION == 2
-  return PyFloat_Check(obj) || PyLong_Check(obj) || PyInt_Check(obj);
-#else
   return PyFloat_Check(obj) || PyLong_Check(obj);
-#endif
 }
 
 inline bool THPUtils_checkScalar(PyObject* obj) {
@@ -124,11 +99,7 @@ inline bool THPUtils_checkScalar(PyObject* obj) {
     return true;
   }
 #endif
-#if PY_MAJOR_VERSION == 2
-  return PyFloat_Check(obj) || PyLong_Check(obj) || PyInt_Check(obj) || PyComplex_Check(obj);
-#else
   return PyFloat_Check(obj) || PyLong_Check(obj) || PyComplex_Check(obj);
-#endif
 }
 
 inline double THPUtils_unpackDouble(PyObject* obj) {
@@ -146,11 +117,6 @@ inline double THPUtils_unpackDouble(PyObject* obj) {
     }
     return (double)value;
   }
-#if PY_MAJOR_VERSION == 2
-  if (PyInt_Check(obj)) {
-    return (double)PyInt_AS_LONG(obj);
-  }
-#endif
   double value = PyFloat_AsDouble(obj);
   if (value == -1 && PyErr_Occurred()) {
     throw python_error();