Grab-bag of minor Python fixes

python_bindings/src/PyConciseCasts.cpp

@@ -6,34 +6,34 @@ namespace PythonBindings {
 void define_concise_casts(py::module &m) {
     // explicit cast should be tried before
     //  the pybind11::implicitly_convertible<T, Expr> conversion
-    m.def("f64", [](double v) {
+    m.def("f64", [](double v) -> Expr {
         return Expr(v);
     });
-    m.def("f32", [](float v) {
+    m.def("f32", [](float v) -> Expr {
         return Expr(v);
     });
-    m.def("i64", [](int64_t v) {
+    m.def("i64", [](int64_t v) -> Expr {
         return Expr(v);
     });
-    m.def("i32", [](int32_t v) {
+    m.def("i32", [](int32_t v) -> Expr {
         return Expr(v);
     });
-    m.def("i16", [](int16_t v) {
+    m.def("i16", [](int16_t v) -> Expr {
         return Expr(v);
     });
-    m.def("i8", [](int8_t v) {
+    m.def("i8", [](int8_t v) -> Expr {
         return Expr(v);
     });
-    m.def("u64", [](uint64_t v) {
+    m.def("u64", [](uint64_t v) -> Expr {
         return Expr(v);
     });
-    m.def("u32", [](uint32_t v) {
+    m.def("u32", [](uint32_t v) -> Expr {
         return Expr(v);
     });
-    m.def("u16", [](uint16_t v) {
+    m.def("u16", [](uint16_t v) -> Expr {
         return Expr(v);
     });
-    m.def("u8", [](uint8_t v) {
+    m.def("u8", [](uint8_t v) -> Expr {
         return Expr(v);
     });
     // pybind11::implicitly_convertible<T, Expr> conversions

python_bindings/src/PyExpr.cpp

@@ -48,6 +48,7 @@ void define_expr(py::module &m) {
             .def("__nonzero__", to_bool)
 
             .def("type", &Expr::type)
+            .def("defined", &Expr::defined)
             .def("__repr__", [](const Expr &e) -> std::string {
                 std::ostringstream o;
                 o << "<halide.Expr of type " << halide_type_to_string(e.type()) << ": " << e << ">";

python_bindings/src/PyImageParam.cpp

@@ -57,7 +57,7 @@ void define_image_param(py::module &m) {
     auto image_param_class =
         py::class_<ImageParam>(m, "ImageParam", output_image_param_class)
             .def(py::init<>())
-            .def(py::init<Type, int>())
+            .def(py::init<Type, int>(), py::arg("type"), py::arg("dimensions"))
             .def(py::init<Type, int, std::string>(), py::arg("type"), py::arg("dimensions"), py::arg("name"))
             .def("set", &ImageParam::set)
             .def("get", &ImageParam::get)

python_bindings/src/PyLoopLevel.cpp

@@ -17,7 +17,9 @@ void define_loop_level(py::module &m) {
             .def_static("root", &LoopLevel::root)
             .def("__repr__", [](const LoopLevel &b) -> std::string {
                 std::ostringstream o;
-                o << "<halide.LoopLevel " << (b.defined() ? b.to_string() : "UNDEF") << ">";
+                // b.to_string() fails for locked LoopLevels. Just output something generic.
+                // o << "<halide.LoopLevel " << (b.defined() ? b.to_string() : "UNDEF") << ">";
+                o << "<halide.LoopLevel>";
                 return o.str();
             });
 }

python_bindings/stub/PyStubImpl.cpp

@@ -141,6 +141,16 @@ py::object generate_impl(const GeneratorFactory &factory, const GeneratorContext
         } else {
             if (py::isinstance<LoopLevel>(value)) {
                 generator_params[name] = value.cast<LoopLevel>();
+            } else if (py::isinstance<py::list>(value)) {
+                // Convert [hl.UInt(8), hl.Int(16)] -> uint8,int16
+                std::string v;
+                for (auto t : value) {
+                    if (!v.empty()) {
+                        v += ",";
+                    }
+                    v += py::str(t).cast<std::string>();
+                }
+                generator_params[name] = v;
             } else {
                 generator_params[name] = py::str(value).cast<std::string>();
             }