Rename examples files, as per #288
This renames example files from `exampleN` to `example-description`.
Specifically, the following renaming is applied:
example1 -> example-methods-and-attributes
example2 -> example-python-types
example3 -> example-operator-overloading
example4 -> example-constants-and-functions
example5 -> example-callbacks (*)
example6 -> example-sequence-and-iterators
example7 -> example-buffers
example8 -> example-custom-ref-counting
example9 -> example-modules
example10 -> example-numpy-vectorize
example11 -> example-arg-keywords-and-defaults
example12 -> example-virtual-functions
example13 -> example-keep-alive
example14 -> example-opaque-types
example15 -> example-pickling
example16 -> example-inheritance
example17 -> example-stl-binders
example18 -> example-eval
example19 -> example-custom-exceptions
* the inheritance parts of example5 are moved into example-inheritance
(previously example16), and the remainder is left as example-callbacks.
This commit also renames the internal variables ("Example1",
"Example2", "Example4", etc.) into non-numeric names ("ExampleMandA",
"ExamplePythonTypes", "ExampleWithEnum", etc.) to correspond to the
file renaming.
The order of tests is preserved, but this can easily be changed if
there is some more natural ordering by updating the list in
examples/CMakeLists.txt.
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 2d30f08..69800f7 100644
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -7,25 +7,25 @@
endif()
set(PYBIND11_EXAMPLES
- example1.cpp
- example2.cpp
- example3.cpp
- example4.cpp
- example5.cpp
- example6.cpp
- example7.cpp
- example8.cpp
- example9.cpp
- example10.cpp
- example11.cpp
- example12.cpp
- example13.cpp
- example14.cpp
- example15.cpp
- example16.cpp
- example17.cpp
- example18.cpp
- example19.cpp
+ example-methods-and-attributes.cpp
+ example-python-types.cpp
+ example-operator-overloading.cpp
+ example-constants-and-functions.cpp
+ example-callbacks.cpp
+ example-sequences-and-iterators.cpp
+ example-buffers.cpp
+ example-smart-ptr.cpp
+ example-modules.cpp
+ example-numpy-vectorize.cpp
+ example-arg-keywords-and-defaults.cpp
+ example-virtual-functions.cpp
+ example-keep-alive.cpp
+ example-opaque-types.cpp
+ example-pickling.cpp
+ example-inheritance.cpp
+ example-stl-binder-vector.cpp
+ example-eval.cpp
+ example-custom-exceptions.cpp
issues.cpp
)
diff --git a/example/example11.cpp b/example/example-arg-keywords-and-defaults.cpp
similarity index 92%
rename from example/example11.cpp
rename to example/example-arg-keywords-and-defaults.cpp
index 4b3c6d0..4e620de 100644
--- a/example/example11.cpp
+++ b/example/example-arg-keywords-and-defaults.cpp
@@ -1,5 +1,5 @@
/*
- example/example11.cpp -- keyword arguments and default values
+ example/example-arg-keywords-and-defaults.cpp -- keyword arguments and default values
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -40,7 +40,7 @@
}
}
-void init_ex11(py::module &m) {
+void init_ex_arg_keywords_and_defaults(py::module &m) {
m.def("kw_func", &kw_func, py::arg("x"), py::arg("y"));
m.def("kw_func2", &kw_func, py::arg("x") = 100, py::arg("y") = 200);
m.def("kw_func3", [](const char *) { }, py::arg("data") = std::string("Hello world!"));
diff --git a/example/example11.py b/example/example-arg-keywords-and-defaults.py
similarity index 100%
rename from example/example11.py
rename to example/example-arg-keywords-and-defaults.py
diff --git a/example/example11.ref b/example/example-arg-keywords-and-defaults.ref
similarity index 100%
rename from example/example11.ref
rename to example/example-arg-keywords-and-defaults.ref
diff --git a/example/example7.cpp b/example/example-buffers.cpp
similarity index 97%
rename from example/example7.cpp
rename to example/example-buffers.cpp
index 6aabf1c..709770b 100644
--- a/example/example7.cpp
+++ b/example/example-buffers.cpp
@@ -1,5 +1,5 @@
/*
- example/example7.cpp -- supporting Pythons' buffer protocol
+ example/example-buffers.cpp -- supporting Pythons' buffer protocol
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -73,7 +73,7 @@
float *m_data;
};
-void init_ex7(py::module &m) {
+void init_ex_buffers(py::module &m) {
py::class_<Matrix> mtx(m, "Matrix");
mtx.def(py::init<size_t, size_t>())
diff --git a/example/example7.py b/example/example-buffers.py
similarity index 100%
rename from example/example7.py
rename to example/example-buffers.py
diff --git a/example/example7.ref b/example/example-buffers.ref
similarity index 100%
rename from example/example7.ref
rename to example/example-buffers.ref
diff --git a/example/example5.cpp b/example/example-callbacks.cpp
similarity index 66%
rename from example/example5.cpp
rename to example/example-callbacks.cpp
index 3c144f2..a7a583e 100644
--- a/example/example5.cpp
+++ b/example/example-callbacks.cpp
@@ -1,6 +1,5 @@
/*
- example/example5.cpp -- inheritance, callbacks, acquiring and releasing the
- global interpreter lock
+ example/example-callbacks.cpp -- callbacks
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -12,36 +11,6 @@
#include <pybind11/functional.h>
-class Pet {
-public:
- Pet(const std::string &name, const std::string &species)
- : m_name(name), m_species(species) {}
- std::string name() const { return m_name; }
- std::string species() const { return m_species; }
-private:
- std::string m_name;
- std::string m_species;
-};
-
-class Dog : public Pet {
-public:
- Dog(const std::string &name) : Pet(name, "dog") {}
- void bark() const { std::cout << "Woof!" << std::endl; }
-};
-
-class Rabbit : public Pet {
-public:
- Rabbit(const std::string &name) : Pet(name, "parrot") {}
-};
-
-void pet_print(const Pet &pet) {
- std::cout << pet.name() + " is a " + pet.species() << std::endl;
-}
-
-void dog_bark(const Dog &dog) {
- dog.bark();
-}
-
bool test_callback1(py::object func) {
func();
return false;
@@ -88,24 +57,7 @@
}
}
-void init_ex5(py::module &m) {
- py::class_<Pet> pet_class(m, "Pet");
- pet_class
- .def(py::init<std::string, std::string>())
- .def("name", &Pet::name)
- .def("species", &Pet::species);
-
- /* One way of declaring a subclass relationship: reference parent's class_ object */
- py::class_<Dog>(m, "Dog", pet_class)
- .def(py::init<std::string>());
-
- /* Another way of declaring a subclass relationship: reference parent's C++ type */
- py::class_<Rabbit>(m, "Rabbit", py::base<Pet>())
- .def(py::init<std::string>());
-
- m.def("pet_print", pet_print);
- m.def("dog_bark", dog_bark);
-
+void init_ex_callbacks(py::module &m) {
m.def("test_callback1", &test_callback1);
m.def("test_callback2", &test_callback2);
m.def("test_callback3", &test_callback3);
diff --git a/example/example5.py b/example/example-callbacks.py
similarity index 100%
rename from example/example5.py
rename to example/example-callbacks.py
diff --git a/example/example5.ref b/example/example-callbacks.ref
similarity index 100%
rename from example/example5.ref
rename to example/example-callbacks.ref
diff --git a/example/example4.cpp b/example/example-constants-and-functions.cpp
similarity index 71%
rename from example/example4.cpp
rename to example/example-constants-and-functions.cpp
index 7e17864..b71856c 100644
--- a/example/example4.cpp
+++ b/example/example-constants-and-functions.cpp
@@ -1,5 +1,5 @@
/*
- example/example4.cpp -- global constants and functions, enumerations, raw byte strings
+ example/example-constants-and-functions.cpp -- global constants and functions, enumerations, raw byte strings
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -14,7 +14,7 @@
ESecondEntry
};
-class Example4 {
+class ExampleWithEnum {
public:
enum EMode {
EFirstMode = 1,
@@ -22,7 +22,7 @@
};
static EMode test_function(EMode mode) {
- std::cout << "Example4::test_function(enum=" << mode << ")" << std::endl;
+ std::cout << "ExampleWithEnum::test_function(enum=" << mode << ")" << std::endl;
return mode;
}
};
@@ -52,7 +52,7 @@
std::cout << "bytes[" << i << "]=" << (int) value[i] << std::endl;
}
-void init_ex4(py::module &m) {
+void init_ex_constants_and_functions(py::module &m) {
m.def("test_function", &test_function1);
m.def("test_function", &test_function2);
m.def("test_function", &test_function3);
@@ -63,11 +63,11 @@
.value("ESecondEntry", ESecondEntry)
.export_values();
- py::class_<Example4> ex4_class(m, "Example4");
- ex4_class.def_static("test_function", &Example4::test_function);
- py::enum_<Example4::EMode>(ex4_class, "EMode")
- .value("EFirstMode", Example4::EFirstMode)
- .value("ESecondMode", Example4::ESecondMode)
+ py::class_<ExampleWithEnum> exenum_class(m, "ExampleWithEnum");
+ exenum_class.def_static("test_function", &ExampleWithEnum::test_function);
+ py::enum_<ExampleWithEnum::EMode>(exenum_class, "EMode")
+ .value("EFirstMode", ExampleWithEnum::EFirstMode)
+ .value("ESecondMode", ExampleWithEnum::ESecondMode)
.export_values();
m.def("return_bytes", &return_bytes);
diff --git a/example/example-constants-and-functions.py b/example/example-constants-and-functions.py
new file mode 100755
index 0000000..607450f
--- /dev/null
+++ b/example/example-constants-and-functions.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+sys.path.append('.')
+
+from example import test_function
+from example import some_constant
+from example import EMyEnumeration
+from example import EFirstEntry
+from example import ExampleWithEnum
+from example import return_bytes
+from example import print_bytes
+
+print(EMyEnumeration)
+print(EMyEnumeration.EFirstEntry)
+print(EMyEnumeration.ESecondEntry)
+print(EFirstEntry)
+
+print(test_function())
+print(test_function(7))
+print(test_function(EMyEnumeration.EFirstEntry))
+print(test_function(EMyEnumeration.ESecondEntry))
+print("enum->integer = %i" % int(EMyEnumeration.ESecondEntry))
+print("integer->enum = %s" % str(EMyEnumeration(2)))
+
+print("A constant = " + str(some_constant))
+
+print(ExampleWithEnum.EMode)
+print(ExampleWithEnum.EMode.EFirstMode)
+print(ExampleWithEnum.EFirstMode)
+ExampleWithEnum.test_function(ExampleWithEnum.EFirstMode)
+
+print("Equality test 1: " + str(
+ ExampleWithEnum.test_function(ExampleWithEnum.EFirstMode) ==
+ ExampleWithEnum.test_function(ExampleWithEnum.EFirstMode)))
+
+print("Inequality test 1: " + str(
+ ExampleWithEnum.test_function(ExampleWithEnum.EFirstMode) !=
+ ExampleWithEnum.test_function(ExampleWithEnum.EFirstMode)))
+
+print("Equality test 2: " + str(
+ ExampleWithEnum.test_function(ExampleWithEnum.EFirstMode) ==
+ ExampleWithEnum.test_function(ExampleWithEnum.ESecondMode)))
+
+print("Inequality test 2: " + str(
+ ExampleWithEnum.test_function(ExampleWithEnum.EFirstMode) !=
+ ExampleWithEnum.test_function(ExampleWithEnum.ESecondMode)))
+
+x = {
+ ExampleWithEnum.test_function(ExampleWithEnum.EFirstMode): 1,
+ ExampleWithEnum.test_function(ExampleWithEnum.ESecondMode): 2
+}
+
+x[ExampleWithEnum.test_function(ExampleWithEnum.EFirstMode)] = 3
+x[ExampleWithEnum.test_function(ExampleWithEnum.ESecondMode)] = 4
+print("Hashing test = " + str(x))
+
+print_bytes(return_bytes())
diff --git a/example/example-constants-and-functions.ref b/example/example-constants-and-functions.ref
new file mode 100644
index 0000000..d2e1731
--- /dev/null
+++ b/example/example-constants-and-functions.ref
@@ -0,0 +1,40 @@
+<class 'example.EMyEnumeration'>
+EMyEnumeration.EFirstEntry
+EMyEnumeration.ESecondEntry
+EMyEnumeration.EFirstEntry
+test_function()
+False
+test_function(7)
+3.5
+test_function(enum=1)
+None
+test_function(enum=2)
+None
+enum->integer = 2
+integer->enum = EMyEnumeration.ESecondEntry
+A constant = 14
+<class 'example.EMode'>
+EMode.EFirstMode
+EMode.EFirstMode
+ExampleWithEnum::test_function(enum=1)
+ExampleWithEnum::test_function(enum=1)
+ExampleWithEnum::test_function(enum=1)
+Equality test 1: True
+ExampleWithEnum::test_function(enum=1)
+ExampleWithEnum::test_function(enum=1)
+Inequality test 1: False
+ExampleWithEnum::test_function(enum=1)
+ExampleWithEnum::test_function(enum=2)
+Equality test 2: False
+ExampleWithEnum::test_function(enum=1)
+ExampleWithEnum::test_function(enum=2)
+Inequality test 2: True
+ExampleWithEnum::test_function(enum=1)
+ExampleWithEnum::test_function(enum=2)
+ExampleWithEnum::test_function(enum=1)
+ExampleWithEnum::test_function(enum=2)
+Hashing test = {EMode.EFirstMode: 3, EMode.ESecondMode: 4}
+bytes[0]=1
+bytes[1]=0
+bytes[2]=2
+bytes[3]=0
diff --git a/example/example19.cpp b/example/example-custom-exceptions.cpp
similarity index 96%
rename from example/example19.cpp
rename to example/example-custom-exceptions.cpp
index e382225..41d51d8 100644
--- a/example/example19.cpp
+++ b/example/example-custom-exceptions.cpp
@@ -1,5 +1,5 @@
/*
- example/example19.cpp -- exception translation
+ example/example-custom-exceptions.cpp -- exception translation
Copyright (c) 2016 Pim Schellart <P.Schellart@princeton.edu>
@@ -66,7 +66,7 @@
throw std::logic_error("this error should fall through to the standard handler");
}
-void init_ex19(py::module &m) {
+void init_ex_custom_exceptions(py::module &m) {
// make a new custom exception and use it as a translation target
static py::exception<MyException> ex(m, "MyException");
py::register_exception_translator([](std::exception_ptr p) {
diff --git a/example/example19.py b/example/example-custom-exceptions.py
similarity index 100%
rename from example/example19.py
rename to example/example-custom-exceptions.py
diff --git a/example/example19.ref b/example/example-custom-exceptions.ref
similarity index 100%
rename from example/example19.ref
rename to example/example-custom-exceptions.ref
diff --git a/example/example18.cpp b/example/example-eval.cpp
similarity index 87%
rename from example/example18.cpp
rename to example/example-eval.cpp
index 8fdab81..f6de893 100644
--- a/example/example18.cpp
+++ b/example/example-eval.cpp
@@ -1,5 +1,5 @@
/*
- example/example18.cpp -- Usage of eval() and eval_file()
+ example/example-eval.cpp -- Usage of eval() and eval_file()
Copyright (c) 2016 Klemens D. Morgenstern
@@ -11,7 +11,7 @@
#include <pybind11/eval.h>
#include "example.h"
-void example18() {
+void example_eval() {
py::module main_module = py::module::import("__main__");
py::object main_namespace = main_module.attr("__dict__");
@@ -59,9 +59,9 @@
main_module.def("call_test2", [&](int value) {val_out = value;});
try {
- result = py::eval_file("example18_call.py", main_namespace);
+ result = py::eval_file("example-eval_call.py", main_namespace);
} catch (...) {
- result = py::eval_file("example/example18_call.py", main_namespace);
+ result = py::eval_file("example/example-eval_call.py", main_namespace);
}
if (val_out == 42 && result == py::none())
@@ -97,6 +97,6 @@
cout << "eval_file failure test failed" << endl;
}
-void init_ex18(py::module & m) {
- m.def("example18", &example18);
+void init_ex_eval(py::module & m) {
+ m.def("example_eval", &example_eval);
}
diff --git a/example/example-eval.py b/example/example-eval.py
new file mode 100644
index 0000000..eec10c3
--- /dev/null
+++ b/example/example-eval.py
@@ -0,0 +1,5 @@
+from example import example_eval
+
+example_eval()
+
+
diff --git a/example/example18.ref b/example/example-eval.ref
similarity index 100%
rename from example/example18.ref
rename to example/example-eval.ref
diff --git a/example/example18_call.py b/example/example-eval_call.py
similarity index 100%
rename from example/example18_call.py
rename to example/example-eval_call.py
diff --git a/example/example-inheritance.cpp b/example/example-inheritance.cpp
new file mode 100644
index 0000000..082978b
--- /dev/null
+++ b/example/example-inheritance.cpp
@@ -0,0 +1,72 @@
+/*
+ example/example-inheritance.cpp -- inheritance, automatic upcasting for polymorphic types
+
+ Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+ All rights reserved. Use of this source code is governed by a
+ BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "example.h"
+
+class Pet {
+public:
+ Pet(const std::string &name, const std::string &species)
+ : m_name(name), m_species(species) {}
+ std::string name() const { return m_name; }
+ std::string species() const { return m_species; }
+private:
+ std::string m_name;
+ std::string m_species;
+};
+
+class Dog : public Pet {
+public:
+ Dog(const std::string &name) : Pet(name, "dog") {}
+ void bark() const { std::cout << "Woof!" << std::endl; }
+};
+
+class Rabbit : public Pet {
+public:
+ Rabbit(const std::string &name) : Pet(name, "parrot") {}
+};
+
+void pet_print(const Pet &pet) {
+ std::cout << pet.name() + " is a " + pet.species() << std::endl;
+}
+
+void dog_bark(const Dog &dog) {
+ dog.bark();
+}
+
+
+struct BaseClass { virtual ~BaseClass() {} };
+struct DerivedClass1 : BaseClass { };
+struct DerivedClass2 : BaseClass { };
+
+void init_ex_inheritance(py::module &m) {
+ py::class_<Pet> pet_class(m, "Pet");
+ pet_class
+ .def(py::init<std::string, std::string>())
+ .def("name", &Pet::name)
+ .def("species", &Pet::species);
+
+ /* One way of declaring a subclass relationship: reference parent's class_ object */
+ py::class_<Dog>(m, "Dog", pet_class)
+ .def(py::init<std::string>());
+
+ /* Another way of declaring a subclass relationship: reference parent's C++ type */
+ py::class_<Rabbit>(m, "Rabbit", py::base<Pet>())
+ .def(py::init<std::string>());
+
+ m.def("pet_print", pet_print);
+ m.def("dog_bark", dog_bark);
+
+ py::class_<BaseClass>(m, "BaseClass").def(py::init<>());
+ py::class_<DerivedClass1>(m, "DerivedClass1").def(py::init<>());
+ py::class_<DerivedClass2>(m, "DerivedClass2").def(py::init<>());
+
+ m.def("return_class_1", []() -> BaseClass* { return new DerivedClass1(); });
+ m.def("return_class_2", []() -> BaseClass* { return new DerivedClass2(); });
+ m.def("return_none", []() -> BaseClass* { return nullptr; });
+}
diff --git a/example/example16.py b/example/example-inheritance.py
similarity index 100%
rename from example/example16.py
rename to example/example-inheritance.py
diff --git a/example/example16.ref b/example/example-inheritance.ref
similarity index 100%
rename from example/example16.ref
rename to example/example-inheritance.ref
diff --git a/example/example13.cpp b/example/example-keep-alive.cpp
similarity index 89%
rename from example/example13.cpp
rename to example/example-keep-alive.cpp
index 6c1b876..c099aa8 100644
--- a/example/example13.cpp
+++ b/example/example-keep-alive.cpp
@@ -1,5 +1,5 @@
/*
- example/example13.cpp -- keep_alive modifier (pybind11's version
+ example/example-keep-alive.cpp -- keep_alive modifier (pybind11's version
of Boost.Python's with_custodian_and_ward / with_custodian_and_ward_postcall)
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -24,7 +24,7 @@
Child *returnChild() { return new Child(); }
};
-void init_ex13(py::module &m) {
+void init_ex_keep_alive(py::module &m) {
py::class_<Parent>(m, "Parent")
.def(py::init<>())
.def("addChild", &Parent::addChild)
diff --git a/example/example13.py b/example/example-keep-alive.py
similarity index 100%
rename from example/example13.py
rename to example/example-keep-alive.py
diff --git a/example/example13.ref b/example/example-keep-alive.ref
similarity index 100%
rename from example/example13.ref
rename to example/example-keep-alive.ref
diff --git a/example/example-methods-and-attributes.cpp b/example/example-methods-and-attributes.cpp
new file mode 100644
index 0000000..800078c
--- /dev/null
+++ b/example/example-methods-and-attributes.cpp
@@ -0,0 +1,92 @@
+/*
+ example/example-methods-and-attributes.cpp -- constructors, deconstructors, attribute access,
+ __str__, argument and return value conventions
+
+ Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+ All rights reserved. Use of this source code is governed by a
+ BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "example.h"
+
+class ExampleMandA {
+public:
+ ExampleMandA() {
+ cout << "Called ExampleMandA default constructor.." << endl;
+ }
+ ExampleMandA(int value) : value(value) {
+ cout << "Called ExampleMandA constructor with value " << value << ".." << endl;
+ }
+ ExampleMandA(const ExampleMandA &e) : value(e.value) {
+ cout << "Called ExampleMandA copy constructor with value " << value << ".." << endl;
+ }
+ ExampleMandA(ExampleMandA &&e) : value(e.value) {
+ cout << "Called ExampleMandA move constructor with value " << value << ".." << endl;
+ e.value = 0;
+ }
+ ~ExampleMandA() {
+ cout << "Called ExampleMandA destructor (" << value << ")" << endl;
+ }
+ std::string toString() {
+ return "ExampleMandA[value=" + std::to_string(value) + "]";
+ }
+
+ void operator=(const ExampleMandA &e) { cout << "Assignment operator" << endl; value = e.value; }
+ void operator=(ExampleMandA &&e) { cout << "Move assignment operator" << endl; value = e.value; e.value = 0;}
+
+ void add1(ExampleMandA other) { value += other.value; } // passing by value
+ void add2(ExampleMandA &other) { value += other.value; } // passing by reference
+ void add3(const ExampleMandA &other) { value += other.value; } // passing by const reference
+ void add4(ExampleMandA *other) { value += other->value; } // passing by pointer
+ void add5(const ExampleMandA *other) { value += other->value; } // passing by const pointer
+
+ void add6(int other) { value += other; } // passing by value
+ void add7(int &other) { value += other; } // passing by reference
+ void add8(const int &other) { value += other; } // passing by const reference
+ void add9(int *other) { value += *other; } // passing by pointer
+ void add10(const int *other) { value += *other; } // passing by const pointer
+
+ ExampleMandA self1() { return *this; } // return by value
+ ExampleMandA &self2() { return *this; } // return by reference
+ const ExampleMandA &self3() { return *this; } // return by const reference
+ ExampleMandA *self4() { return this; } // return by pointer
+ const ExampleMandA *self5() { return this; } // return by const pointer
+
+ int internal1() { return value; } // return by value
+ int &internal2() { return value; } // return by reference
+ const int &internal3() { return value; } // return by const reference
+ int *internal4() { return &value; } // return by pointer
+ const int *internal5() { return &value; } // return by const pointer
+
+ int value = 0;
+};
+
+void init_ex_methods_and_attributes(py::module &m) {
+ py::class_<ExampleMandA>(m, "ExampleMandA")
+ .def(py::init<>())
+ .def(py::init<int>())
+ .def(py::init<const ExampleMandA&>())
+ .def("add1", &ExampleMandA::add1)
+ .def("add2", &ExampleMandA::add2)
+ .def("add3", &ExampleMandA::add3)
+ .def("add4", &ExampleMandA::add4)
+ .def("add5", &ExampleMandA::add5)
+ .def("add6", &ExampleMandA::add6)
+ .def("add7", &ExampleMandA::add7)
+ .def("add8", &ExampleMandA::add8)
+ .def("add9", &ExampleMandA::add9)
+ .def("add10", &ExampleMandA::add10)
+ .def("self1", &ExampleMandA::self1)
+ .def("self2", &ExampleMandA::self2)
+ .def("self3", &ExampleMandA::self3)
+ .def("self4", &ExampleMandA::self4)
+ .def("self5", &ExampleMandA::self5)
+ .def("internal1", &ExampleMandA::internal1)
+ .def("internal2", &ExampleMandA::internal2)
+ .def("internal3", &ExampleMandA::internal3)
+ .def("internal4", &ExampleMandA::internal4)
+ .def("internal5", &ExampleMandA::internal5)
+ .def("__str__", &ExampleMandA::toString)
+ .def_readwrite("value", &ExampleMandA::value);
+}
diff --git a/example/example1.py b/example/example-methods-and-attributes.py
similarity index 89%
rename from example/example1.py
rename to example/example-methods-and-attributes.py
index f89b662..229e1c9 100755
--- a/example/example1.py
+++ b/example/example-methods-and-attributes.py
@@ -3,10 +3,10 @@
import sys
sys.path.append('.')
-from example import Example1
+from example import ExampleMandA
-instance1 = Example1()
-instance2 = Example1(32)
+instance1 = ExampleMandA()
+instance2 = ExampleMandA(32)
instance1.add1(instance2)
instance1.add2(instance2)
instance1.add3(instance2)
diff --git a/example/example-methods-and-attributes.ref b/example/example-methods-and-attributes.ref
new file mode 100644
index 0000000..9527790
--- /dev/null
+++ b/example/example-methods-and-attributes.ref
@@ -0,0 +1,26 @@
+Called ExampleMandA default constructor..
+Called ExampleMandA constructor with value 32..
+Called ExampleMandA copy constructor with value 32..
+Called ExampleMandA copy constructor with value 32..
+Called ExampleMandA destructor (32)
+Called ExampleMandA destructor (32)
+Instance 1: ExampleMandA[value=320]
+Instance 2: ExampleMandA[value=32]
+Called ExampleMandA copy constructor with value 320..
+Called ExampleMandA move constructor with value 320..
+Called ExampleMandA destructor (0)
+ExampleMandA[value=320]
+Called ExampleMandA destructor (320)
+ExampleMandA[value=320]
+ExampleMandA[value=320]
+ExampleMandA[value=320]
+ExampleMandA[value=320]
+320
+320
+320
+320
+320
+Instance 1, direct access = 320
+Instance 1: ExampleMandA[value=100]
+Called ExampleMandA destructor (32)
+Called ExampleMandA destructor (100)
diff --git a/example/example9.cpp b/example/example-modules.cpp
similarity index 93%
rename from example/example9.cpp
rename to example/example-modules.cpp
index ca75ecc..fdaf72e 100644
--- a/example/example9.cpp
+++ b/example/example-modules.cpp
@@ -1,5 +1,5 @@
/*
- example/example9.cpp -- nested modules, importing modules, and
+ example/example-modules.cpp -- nested modules, importing modules, and
internal references
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -36,7 +36,7 @@
A a2{2};
};
-void init_ex9(py::module &m) {
+void init_ex_modules(py::module &m) {
py::module m_sub = m.def_submodule("submodule");
m_sub.def("submodule_func", &submodule_func);
diff --git a/example/example9.py b/example/example-modules.py
similarity index 100%
rename from example/example9.py
rename to example/example-modules.py
diff --git a/example/example9.ref b/example/example-modules.ref
similarity index 100%
rename from example/example9.ref
rename to example/example-modules.ref
diff --git a/example/example10.cpp b/example/example-numpy-vectorize.cpp
similarity index 91%
rename from example/example10.cpp
rename to example/example-numpy-vectorize.cpp
index 06528c2..8780d28 100644
--- a/example/example10.cpp
+++ b/example/example-numpy-vectorize.cpp
@@ -1,5 +1,5 @@
/*
- example/example10.cpp -- auto-vectorize functions over NumPy array
+ example/example-numpy-vectorize.cpp -- auto-vectorize functions over NumPy array
arguments
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -20,7 +20,7 @@
return c * std::complex<double>(2.f);
}
-void init_ex10(py::module &m) {
+void init_ex_numpy_vectorize(py::module &m) {
// Vectorize all arguments of a function (though non-vector arguments are also allowed)
m.def("vectorized_func", py::vectorize(my_func));
diff --git a/example/example10.py b/example/example-numpy-vectorize.py
similarity index 100%
rename from example/example10.py
rename to example/example-numpy-vectorize.py
diff --git a/example/example10.ref b/example/example-numpy-vectorize.ref
similarity index 100%
rename from example/example10.ref
rename to example/example-numpy-vectorize.ref
diff --git a/example/example14.cpp b/example/example-opaque-types.cpp
similarity index 94%
rename from example/example14.cpp
rename to example/example-opaque-types.cpp
index ad67fe4..2c24f35 100644
--- a/example/example14.cpp
+++ b/example/example-opaque-types.cpp
@@ -1,5 +1,5 @@
/*
- example/example14.cpp -- opaque types, passing void pointers
+ example/example-opaque-types.cpp -- opaque types, passing void pointers
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -21,7 +21,7 @@
/* IMPORTANT: Disable internal pybind11 translation mechanisms for STL data structures */
PYBIND11_MAKE_OPAQUE(StringList);
-void init_ex14(py::module &m) {
+void init_ex_opaque_types(py::module &m) {
py::class_<StringList>(m, "StringList")
.def(py::init<>())
.def("pop_back", &StringList::pop_back)
diff --git a/example/example14.py b/example/example-opaque-types.py
similarity index 90%
rename from example/example14.py
rename to example/example-opaque-types.py
index c653e0c..8fd09f6 100644
--- a/example/example14.py
+++ b/example/example-opaque-types.py
@@ -8,7 +8,7 @@
from example import return_void_ptr, print_void_ptr
from example import return_null_str, print_null_str
from example import return_unique_ptr
-from example import Example1
+from example import ExampleMandA
#####
@@ -33,7 +33,7 @@
#####
print_void_ptr(return_void_ptr())
-print_void_ptr(Example1()) # Should also work for other C++ types
+print_void_ptr(ExampleMandA()) # Should also work for other C++ types
try:
print_void_ptr([1, 2, 3]) # This should not work
diff --git a/example/example14.ref b/example/example-opaque-types.ref
similarity index 85%
rename from example/example14.ref
rename to example/example-opaque-types.ref
index 44e6820..a6672fd 100644
--- a/example/example14.ref
+++ b/example/example-opaque-types.ref
@@ -6,9 +6,9 @@
Opaque list: []
Opaque list: [Element 1, Element 3]
Got void ptr : 0x1234
-Called Example1 default constructor..
+Called ExampleMandA default constructor..
Got void ptr : 0x7f9ba0f3c430
-Called Example1 destructor (0)
+Called ExampleMandA destructor (0)
Caught expected exception: Incompatible function arguments. The following argument types are supported:
1. (capsule) -> NoneType
Invoked with: [1, 2, 3]
diff --git a/example/example3.cpp b/example/example-operator-overloading.cpp
similarity index 95%
rename from example/example3.cpp
rename to example/example-operator-overloading.cpp
index af956b1..ff5e658 100644
--- a/example/example3.cpp
+++ b/example/example-operator-overloading.cpp
@@ -1,5 +1,5 @@
/*
- example/example3.cpp -- operator overloading
+ example/example-operator-overloading.cpp -- operator overloading
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -52,7 +52,7 @@
};
-void init_ex3(py::module &m) {
+void init_ex_operator_overloading(py::module &m) {
py::class_<Vector2>(m, "Vector2")
.def(py::init<float, float>())
.def(py::self + py::self)
diff --git a/example/example3.py b/example/example-operator-overloading.py
similarity index 100%
rename from example/example3.py
rename to example/example-operator-overloading.py
diff --git a/example/example3.ref b/example/example-operator-overloading.ref
similarity index 100%
rename from example/example3.ref
rename to example/example-operator-overloading.ref
diff --git a/example/example15.cpp b/example/example-pickling.cpp
similarity index 94%
rename from example/example15.cpp
rename to example/example-pickling.cpp
index acdd368..b89f78a 100644
--- a/example/example15.cpp
+++ b/example/example-pickling.cpp
@@ -1,5 +1,5 @@
/*
- example/example15.cpp -- pickle support
+ example/example-pickling.cpp -- pickle support
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -24,7 +24,7 @@
int m_extra2 = 0;
};
-void init_ex15(py::module &m) {
+void init_ex_pickling(py::module &m) {
py::class_<Pickleable>(m, "Pickleable")
.def(py::init<std::string>())
.def("value", &Pickleable::value)
diff --git a/example/example15.py b/example/example-pickling.py
similarity index 100%
rename from example/example15.py
rename to example/example-pickling.py
diff --git a/example/example15.ref b/example/example-pickling.ref
similarity index 100%
rename from example/example15.ref
rename to example/example-pickling.ref
diff --git a/example/example2.cpp b/example/example-python-types.cpp
similarity index 65%
rename from example/example2.cpp
rename to example/example-python-types.cpp
index 4b15823..9765835 100644
--- a/example/example2.cpp
+++ b/example/example-python-types.cpp
@@ -1,5 +1,5 @@
/*
- example/example2.cpp2 -- singleton design pattern, static functions and
+ example/example-python-types.cpp2 -- singleton design pattern, static functions and
variables, passing and interacting with Python types
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -16,13 +16,13 @@
# include <fcntl.h>
#endif
-class Example2 {
+class ExamplePythonTypes {
public:
- static Example2 *new_instance() {
- return new Example2();
+ static ExamplePythonTypes *new_instance() {
+ return new ExamplePythonTypes();
}
- ~Example2() {
- std::cout << "Destructing Example2" << std::endl;
+ ~ExamplePythonTypes() {
+ std::cout << "Destructing ExamplePythonTypes" << std::endl;
}
/* Create and return a Python dictionary */
@@ -142,31 +142,31 @@
static const int value2;
};
-int Example2::value = 0;
-const int Example2::value2 = 5;
+int ExamplePythonTypes::value = 0;
+const int ExamplePythonTypes::value2 = 5;
-void init_ex2(py::module &m) {
+void init_ex_python_types(py::module &m) {
/* No constructor is explicitly defined below. An exception is raised when
trying to construct it directly from Python */
- py::class_<Example2>(m, "Example2", "Example 2 documentation")
- .def("get_dict", &Example2::get_dict, "Return a Python dictionary")
- .def("get_dict_2", &Example2::get_dict_2, "Return a C++ dictionary")
- .def("get_list", &Example2::get_list, "Return a Python list")
- .def("get_list_2", &Example2::get_list_2, "Return a C++ list")
- .def("get_set", &Example2::get_set, "Return a Python set")
- .def("get_set2", &Example2::get_set_2, "Return a C++ set")
- .def("get_array", &Example2::get_array, "Return a C++ array")
- .def("print_dict", &Example2::print_dict, "Print entries of a Python dictionary")
- .def("print_dict_2", &Example2::print_dict_2, "Print entries of a C++ dictionary")
- .def("print_set", &Example2::print_set, "Print entries of a Python set")
- .def("print_set_2", &Example2::print_set_2, "Print entries of a C++ set")
- .def("print_list", &Example2::print_list, "Print entries of a Python list")
- .def("print_list_2", &Example2::print_list_2, "Print entries of a C++ list")
- .def("print_array", &Example2::print_array, "Print entries of a C++ array")
- .def("pair_passthrough", &Example2::pair_passthrough, "Return a pair in reversed order")
- .def("tuple_passthrough", &Example2::tuple_passthrough, "Return a triple in reversed order")
- .def("throw_exception", &Example2::throw_exception, "Throw an exception")
- .def_static("new_instance", &Example2::new_instance, "Return an instance")
- .def_readwrite_static("value", &Example2::value, "Static value member")
- .def_readonly_static("value2", &Example2::value2, "Static value member (readonly)");
+ py::class_<ExamplePythonTypes>(m, "ExamplePythonTypes", "Example 2 documentation")
+ .def("get_dict", &ExamplePythonTypes::get_dict, "Return a Python dictionary")
+ .def("get_dict_2", &ExamplePythonTypes::get_dict_2, "Return a C++ dictionary")
+ .def("get_list", &ExamplePythonTypes::get_list, "Return a Python list")
+ .def("get_list_2", &ExamplePythonTypes::get_list_2, "Return a C++ list")
+ .def("get_set", &ExamplePythonTypes::get_set, "Return a Python set")
+ .def("get_set2", &ExamplePythonTypes::get_set_2, "Return a C++ set")
+ .def("get_array", &ExamplePythonTypes::get_array, "Return a C++ array")
+ .def("print_dict", &ExamplePythonTypes::print_dict, "Print entries of a Python dictionary")
+ .def("print_dict_2", &ExamplePythonTypes::print_dict_2, "Print entries of a C++ dictionary")
+ .def("print_set", &ExamplePythonTypes::print_set, "Print entries of a Python set")
+ .def("print_set_2", &ExamplePythonTypes::print_set_2, "Print entries of a C++ set")
+ .def("print_list", &ExamplePythonTypes::print_list, "Print entries of a Python list")
+ .def("print_list_2", &ExamplePythonTypes::print_list_2, "Print entries of a C++ list")
+ .def("print_array", &ExamplePythonTypes::print_array, "Print entries of a C++ array")
+ .def("pair_passthrough", &ExamplePythonTypes::pair_passthrough, "Return a pair in reversed order")
+ .def("tuple_passthrough", &ExamplePythonTypes::tuple_passthrough, "Return a triple in reversed order")
+ .def("throw_exception", &ExamplePythonTypes::throw_exception, "Throw an exception")
+ .def_static("new_instance", &ExamplePythonTypes::new_instance, "Return an instance")
+ .def_readwrite_static("value", &ExamplePythonTypes::value, "Static value member")
+ .def_readonly_static("value2", &ExamplePythonTypes::value2, "Static value member (readonly)");
}
diff --git a/example/example2.py b/example/example-python-types.py
similarity index 62%
rename from example/example2.py
rename to example/example-python-types.py
index d335acc..df5a244 100755
--- a/example/example2.py
+++ b/example/example-python-types.py
@@ -4,23 +4,23 @@
sys.path.append('.')
import example
-from example import Example2
+from example import ExamplePythonTypes
-Example2.value = 15
-print(Example2.value)
-print(Example2.value2)
+ExamplePythonTypes.value = 15
+print(ExamplePythonTypes.value)
+print(ExamplePythonTypes.value2)
try:
- Example2()
+ ExamplePythonTypes()
except Exception as e:
print(e)
try:
- Example2.value2 = 15
+ ExamplePythonTypes.value2 = 15
except Exception as e:
print(e)
-instance = Example2.new_instance()
+instance = ExamplePythonTypes.new_instance()
dict_result = instance.get_dict()
dict_result['key2'] = 'value2'
@@ -58,10 +58,10 @@
print(instance.pair_passthrough((True, "test")))
print(instance.tuple_passthrough((True, "test", 5)))
-print(pydoc.render_doc(Example2, "Help on %s"))
+print(pydoc.render_doc(ExamplePythonTypes, "Help on %s"))
print("__name__(example) = %s" % example.__name__)
-print("__name__(example.Example2) = %s" % Example2.__name__)
-print("__module__(example.Example2) = %s" % Example2.__module__)
-print("__name__(example.Example2.get_set) = %s" % Example2.get_set.__name__)
-print("__module__(example.Example2.get_set) = %s" % Example2.get_set.__module__)
+print("__name__(example.ExamplePythonTypes) = %s" % ExamplePythonTypes.__name__)
+print("__module__(example.ExamplePythonTypes) = %s" % ExamplePythonTypes.__module__)
+print("__name__(example.ExamplePythonTypes.get_set) = %s" % ExamplePythonTypes.get_set.__name__)
+print("__module__(example.ExamplePythonTypes.get_set) = %s" % ExamplePythonTypes.get_set.__module__)
diff --git a/example/example2.ref b/example/example-python-types.ref
similarity index 60%
rename from example/example2.ref
rename to example/example-python-types.ref
index fd6c83d..2a0237c 100644
--- a/example/example2.ref
+++ b/example/example-python-types.ref
@@ -1,6 +1,6 @@
15
5
-example.Example2: No constructor defined!
+example.ExamplePythonTypes: No constructor defined!
can't set attribute
key: key2, value=value2
key: key, value=value
@@ -23,9 +23,9 @@
This exception was intentionally thrown.
(u'test', True)
(5L, u'test', True)
-Help on class Example2 in module example
+Help on class ExamplePythonTypes in module example
-class EExxaammppllee22(__builtin__.object)
+class EExxaammpplleePPyytthhoonnTTyyppeess(__builtin__.object)
| Example 2 documentation
|
| Methods defined here:
@@ -34,104 +34,104 @@
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| ggeett__aarrrraayy(...)
- | Signature : (example.Example2) -> list<unicode>[2]
+ | Signature : (example.ExamplePythonTypes) -> list<unicode>[2]
|
| Return a C++ array
|
| ggeett__ddiicctt(...)
- | Signature : (example.Example2) -> dict
+ | Signature : (example.ExamplePythonTypes) -> dict
|
| Return a Python dictionary
|
| ggeett__ddiicctt__22(...)
- | Signature : (example.Example2) -> dict<unicode, unicode>
+ | Signature : (example.ExamplePythonTypes) -> dict<unicode, unicode>
|
| Return a C++ dictionary
|
| ggeett__lliisstt(...)
- | Signature : (example.Example2) -> list
+ | Signature : (example.ExamplePythonTypes) -> list
|
| Return a Python list
|
| ggeett__lliisstt__22(...)
- | Signature : (example.Example2) -> list<unicode>
+ | Signature : (example.ExamplePythonTypes) -> list<unicode>
|
| Return a C++ list
|
| ggeett__sseett(...)
- | Signature : (example.Example2) -> set
+ | Signature : (example.ExamplePythonTypes) -> set
|
| Return a Python set
|
| ggeett__sseett22(...)
- | Signature : (example.Example2) -> set
+ | Signature : (example.ExamplePythonTypes) -> set
|
| Return a C++ set
|
| ppaaiirr__ppaasssstthhrroouugghh(...)
- | Signature : (example.Example2, (bool, unicode)) -> (unicode, bool)
+ | Signature : (example.ExamplePythonTypes, (bool, unicode)) -> (unicode, bool)
|
| Return a pair in reversed order
|
| pprriinntt__aarrrraayy(...)
- | Signature : (example.Example2, list<unicode>[2]) -> NoneType
+ | Signature : (example.ExamplePythonTypes, list<unicode>[2]) -> NoneType
|
| Print entries of a C++ array
|
| pprriinntt__ddiicctt(...)
- | Signature : (example.Example2, dict) -> NoneType
+ | Signature : (example.ExamplePythonTypes, dict) -> NoneType
|
| Print entries of a Python dictionary
|
| pprriinntt__ddiicctt__22(...)
- | Signature : (example.Example2, dict<unicode, unicode>) -> NoneType
+ | Signature : (example.ExamplePythonTypes, dict<unicode, unicode>) -> NoneType
|
| Print entries of a C++ dictionary
|
| pprriinntt__lliisstt(...)
- | Signature : (example.Example2, list) -> NoneType
+ | Signature : (example.ExamplePythonTypes, list) -> NoneType
|
| Print entries of a Python list
|
| pprriinntt__lliisstt__22(...)
- | Signature : (example.Example2, list<unicode>) -> NoneType
+ | Signature : (example.ExamplePythonTypes, list<unicode>) -> NoneType
|
| Print entries of a C++ list
|
| pprriinntt__sseett(...)
- | Signature : (example.Example2, set) -> NoneType
+ | Signature : (example.ExamplePythonTypes, set) -> NoneType
|
| Print entries of a Python set
|
| pprriinntt__sseett__22(...)
- | Signature : (example.Example2, set<unicode>) -> NoneType
+ | Signature : (example.ExamplePythonTypes, set<unicode>) -> NoneType
|
| Print entries of a C++ set
|
| tthhrrooww__eexxcceeppttiioonn(...)
- | Signature : (example.Example2) -> NoneType
+ | Signature : (example.ExamplePythonTypes) -> NoneType
|
| Throw an exception
|
| ttuuppllee__ppaasssstthhrroouugghh(...)
- | Signature : (example.Example2, (bool, unicode, int)) -> (int, unicode, bool)
+ | Signature : (example.ExamplePythonTypes, (bool, unicode, int)) -> (int, unicode, bool)
|
| Return a triple in reversed order
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
- | ____nneeww____ = <built-in method __new__ of example.Example2__Meta object>
+ | ____nneeww____ = <built-in method __new__ of example.ExamplePythonTypes__Meta object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| nneeww__iinnssttaannccee = <built-in method new_instance of PyCapsule object>
- | Signature : () -> example.Example2
+ | Signature : () -> example.ExamplePythonTypes
|
| Return an instance
__name__(example) = example
-__name__(example.Example2) = Example2
-__module__(example.Example2) = example
-__name__(example.Example2.get_set) = get_set
-__module__(example.Example2.get_set) = example
-Destructing Example2
+__name__(example.ExamplePythonTypes) = ExamplePythonTypes
+__module__(example.ExamplePythonTypes) = example
+__name__(example.ExamplePythonTypes.get_set) = get_set
+__module__(example.ExamplePythonTypes.get_set) = example
+Destructing ExamplePythonTypes
diff --git a/example/example6.cpp b/example/example-sequences-and-iterators.cpp
similarity index 97%
rename from example/example6.cpp
rename to example/example-sequences-and-iterators.cpp
index e0bfb9e..4233649 100644
--- a/example/example6.cpp
+++ b/example/example-sequences-and-iterators.cpp
@@ -1,5 +1,5 @@
/*
- example/example6.cpp -- supporting Pythons' sequence protocol, iterators,
+ example/example-sequences-and-iterators.cpp -- supporting Pythons' sequence protocol, iterators,
etc.
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -109,7 +109,7 @@
float *m_data;
};
-void init_ex6(py::module &m) {
+void init_ex_sequences_and_iterators(py::module &m) {
py::class_<Sequence> seq(m, "Sequence");
seq.def(py::init<size_t>())
diff --git a/example/example6.py b/example/example-sequences-and-iterators.py
similarity index 100%
rename from example/example6.py
rename to example/example-sequences-and-iterators.py
diff --git a/example/example6.ref b/example/example-sequences-and-iterators.ref
similarity index 100%
rename from example/example6.ref
rename to example/example-sequences-and-iterators.ref
diff --git a/example/example8.cpp b/example/example-smart-ptr.cpp
similarity index 97%
rename from example/example8.cpp
rename to example/example-smart-ptr.cpp
index dbdd421..7ae1db8 100644
--- a/example/example8.cpp
+++ b/example/example-smart-ptr.cpp
@@ -1,5 +1,5 @@
/*
- example/example8.cpp -- binding classes with custom reference counting,
+ example/example-smart-ptr.cpp -- binding classes with custom reference counting,
implicit conversions between types
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -105,7 +105,7 @@
void print_myobject3_3(const std::shared_ptr<MyObject3> &obj) { std::cout << obj->toString() << std::endl; }
void print_myobject3_4(const std::shared_ptr<MyObject3> *obj) { std::cout << (*obj)->toString() << std::endl; }
-void init_ex8(py::module &m) {
+void init_ex_smart_ptr(py::module &m) {
py::class_<Object, ref<Object>> obj(m, "Object");
obj.def("getRefCount", &Object::getRefCount);
diff --git a/example/example8.py b/example/example-smart-ptr.py
similarity index 100%
rename from example/example8.py
rename to example/example-smart-ptr.py
diff --git a/example/example8.ref b/example/example-smart-ptr.ref
similarity index 100%
rename from example/example8.ref
rename to example/example-smart-ptr.ref
diff --git a/example/example17.cpp b/example/example-stl-binder-vector.cpp
similarity index 84%
rename from example/example17.cpp
rename to example/example-stl-binder-vector.cpp
index 8fd4ad6..fa687a2 100644
--- a/example/example17.cpp
+++ b/example/example-stl-binder-vector.cpp
@@ -1,5 +1,5 @@
/*
- example/example17.cpp -- Usage of stl_binders functions
+ example/example-stl-binder-vector.cpp -- Usage of stl_binders functions
Copyright (c) 2016 Sergey Lyskov
@@ -24,7 +24,7 @@
return s;
}
-void init_ex17(py::module &m) {
+void init_ex_stl_binder_vector(py::module &m) {
pybind11::class_<El>(m, "El")
.def(pybind11::init<int>());
diff --git a/example/example17.py b/example/example-stl-binder-vector.py
similarity index 100%
rename from example/example17.py
rename to example/example-stl-binder-vector.py
diff --git a/example/example17.ref b/example/example-stl-binder-vector.ref
similarity index 100%
rename from example/example17.ref
rename to example/example-stl-binder-vector.ref
diff --git a/example/example-virtual-functions.cpp b/example/example-virtual-functions.cpp
new file mode 100644
index 0000000..dc39f26
--- /dev/null
+++ b/example/example-virtual-functions.cpp
@@ -0,0 +1,98 @@
+/*
+ example/example-virtual-functions.cpp -- overriding virtual functions from Python
+
+ Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
+
+ All rights reserved. Use of this source code is governed by a
+ BSD-style license that can be found in the LICENSE file.
+*/
+
+#include "example.h"
+#include <pybind11/functional.h>
+
+/* This is an example class that we'll want to be able to extend from Python */
+class ExampleVirt {
+public:
+ ExampleVirt(int state) : state(state) {
+ cout << "Constructing ExampleVirt.." << endl;
+ }
+
+ ~ExampleVirt() {
+ cout << "Destructing ExampleVirt.." << endl;
+ }
+
+ virtual int run(int value) {
+ std::cout << "Original implementation of ExampleVirt::run(state=" << state
+ << ", value=" << value << ")" << std::endl;
+ return state + value;
+ }
+
+ virtual bool run_bool() = 0;
+ virtual void pure_virtual() = 0;
+private:
+ int state;
+};
+
+/* This is a wrapper class that must be generated */
+class PyExampleVirt : public ExampleVirt {
+public:
+ using ExampleVirt::ExampleVirt; /* Inherit constructors */
+
+ virtual int run(int value) {
+ /* Generate wrapping code that enables native function overloading */
+ PYBIND11_OVERLOAD(
+ int, /* Return type */
+ ExampleVirt, /* Parent class */
+ run, /* Name of function */
+ value /* Argument(s) */
+ );
+ }
+
+ virtual bool run_bool() {
+ PYBIND11_OVERLOAD_PURE(
+ bool, /* Return type */
+ ExampleVirt, /* Parent class */
+ run_bool, /* Name of function */
+ /* This function has no arguments. The trailing comma
+ in the previous line is needed for some compilers */
+ );
+ }
+
+ virtual void pure_virtual() {
+ PYBIND11_OVERLOAD_PURE(
+ void, /* Return type */
+ ExampleVirt, /* Parent class */
+ pure_virtual, /* Name of function */
+ /* This function has no arguments. The trailing comma
+ in the previous line is needed for some compilers */
+ );
+ }
+};
+
+int runExampleVirt(ExampleVirt *ex, int value) {
+ return ex->run(value);
+}
+
+bool runExampleVirtBool(ExampleVirt* ex) {
+ return ex->run_bool();
+}
+
+void runExampleVirtVirtual(ExampleVirt *ex) {
+ ex->pure_virtual();
+}
+
+void init_ex_virtual_functions(py::module &m) {
+ /* Important: indicate the trampoline class PyExampleVirt using the third
+ argument to py::class_. The second argument with the unique pointer
+ is simply the default holder type used by pybind11. */
+ py::class_<ExampleVirt, std::unique_ptr<ExampleVirt>, PyExampleVirt>(m, "ExampleVirt")
+ .def(py::init<int>())
+ /* Reference original class in function definitions */
+ .def("run", &ExampleVirt::run)
+ .def("run_bool", &ExampleVirt::run_bool)
+ .def("pure_virtual", &ExampleVirt::pure_virtual);
+
+ m.def("runExampleVirt", &runExampleVirt);
+ m.def("runExampleVirtBool", &runExampleVirtBool);
+ m.def("runExampleVirtVirtual", &runExampleVirtVirtual);
+}
diff --git a/example/example-virtual-functions.py b/example/example-virtual-functions.py
new file mode 100644
index 0000000..9580019
--- /dev/null
+++ b/example/example-virtual-functions.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+sys.path.append('.')
+
+from example import ExampleVirt, runExampleVirt, runExampleVirtVirtual, runExampleVirtBool
+
+
+class ExtendedExampleVirt(ExampleVirt):
+ def __init__(self, state):
+ super(ExtendedExampleVirt, self).__init__(state + 1)
+ self.data = "Hello world"
+
+ def run(self, value):
+ print('ExtendedExampleVirt::run(%i), calling parent..' % value)
+ return super(ExtendedExampleVirt, self).run(value + 1)
+
+ def run_bool(self):
+ print('ExtendedExampleVirt::run_bool()')
+ return False
+
+ def pure_virtual(self):
+ print('ExtendedExampleVirt::pure_virtual(): %s' % self.data)
+
+
+ex12 = ExampleVirt(10)
+print(runExampleVirt(ex12, 20))
+try:
+ runExampleVirtVirtual(ex12)
+except Exception as e:
+ print("Caught expected exception: " + str(e))
+
+ex12p = ExtendedExampleVirt(10)
+print(runExampleVirt(ex12p, 20))
+print(runExampleVirtBool(ex12p))
+runExampleVirtVirtual(ex12p)
diff --git a/example/example-virtual-functions.ref b/example/example-virtual-functions.ref
new file mode 100644
index 0000000..e2071ad
--- /dev/null
+++ b/example/example-virtual-functions.ref
@@ -0,0 +1,13 @@
+Constructing ExampleVirt..
+Original implementation of ExampleVirt::run(state=10, value=20)
+30
+Caught expected exception: Tried to call pure virtual function "ExampleVirt::pure_virtual"
+Constructing ExampleVirt..
+ExtendedExampleVirt::run(20), calling parent..
+Original implementation of ExampleVirt::run(state=11, value=21)
+32
+ExtendedExampleVirt::run_bool()
+False
+ExtendedExampleVirt::pure_virtual(): Hello world
+Destructing ExampleVirt..
+Destructing ExampleVirt..
diff --git a/example/example.cpp b/example/example.cpp
index ad37273..e62fde7 100644
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -9,25 +9,25 @@
#include "example.h"
-void init_ex1(py::module &);
-void init_ex2(py::module &);
-void init_ex3(py::module &);
-void init_ex4(py::module &);
-void init_ex5(py::module &);
-void init_ex6(py::module &);
-void init_ex7(py::module &);
-void init_ex8(py::module &);
-void init_ex9(py::module &);
-void init_ex10(py::module &);
-void init_ex11(py::module &);
-void init_ex12(py::module &);
-void init_ex13(py::module &);
-void init_ex14(py::module &);
-void init_ex15(py::module &);
-void init_ex16(py::module &);
-void init_ex17(py::module &);
-void init_ex18(py::module &);
-void init_ex19(py::module &);
+void init_ex_methods_and_attributes(py::module &);
+void init_ex_python_types(py::module &);
+void init_ex_operator_overloading(py::module &);
+void init_ex_constants_and_functions(py::module &);
+void init_ex_callbacks(py::module &);
+void init_ex_sequences_and_iterators(py::module &);
+void init_ex_buffers(py::module &);
+void init_ex_smart_ptr(py::module &);
+void init_ex_modules(py::module &);
+void init_ex_numpy_vectorize(py::module &);
+void init_ex_arg_keywords_and_defaults(py::module &);
+void init_ex_virtual_functions(py::module &);
+void init_ex_keep_alive(py::module &);
+void init_ex_opaque_types(py::module &);
+void init_ex_pickling(py::module &);
+void init_ex_inheritance(py::module &);
+void init_ex_stl_binder_vector(py::module &);
+void init_ex_eval(py::module &);
+void init_ex_custom_exceptions(py::module &);
void init_issues(py::module &);
#if defined(PYBIND11_TEST_EIGEN)
@@ -37,25 +37,25 @@
PYBIND11_PLUGIN(example) {
py::module m("example", "pybind example plugin");
- init_ex1(m);
- init_ex2(m);
- init_ex3(m);
- init_ex4(m);
- init_ex5(m);
- init_ex6(m);
- init_ex7(m);
- init_ex8(m);
- init_ex9(m);
- init_ex10(m);
- init_ex11(m);
- init_ex12(m);
- init_ex13(m);
- init_ex14(m);
- init_ex15(m);
- init_ex16(m);
- init_ex17(m);
- init_ex18(m);
- init_ex19(m);
+ init_ex_methods_and_attributes(m);
+ init_ex_python_types(m);
+ init_ex_operator_overloading(m);
+ init_ex_constants_and_functions(m);
+ init_ex_callbacks(m);
+ init_ex_sequences_and_iterators(m);
+ init_ex_buffers(m);
+ init_ex_smart_ptr(m);
+ init_ex_modules(m);
+ init_ex_numpy_vectorize(m);
+ init_ex_arg_keywords_and_defaults(m);
+ init_ex_virtual_functions(m);
+ init_ex_keep_alive(m);
+ init_ex_opaque_types(m);
+ init_ex_pickling(m);
+ init_ex_inheritance(m);
+ init_ex_stl_binder_vector(m);
+ init_ex_eval(m);
+ init_ex_custom_exceptions(m);
init_issues(m);
#if defined(PYBIND11_TEST_EIGEN)
diff --git a/example/example1.cpp b/example/example1.cpp
deleted file mode 100644
index dd651fb..0000000
--- a/example/example1.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- example/example1.cpp -- constructors, deconstructors, attribute access,
- __str__, argument and return value conventions
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "example.h"
-
-class Example1 {
-public:
- Example1() {
- cout << "Called Example1 default constructor.." << endl;
- }
- Example1(int value) : value(value) {
- cout << "Called Example1 constructor with value " << value << ".." << endl;
- }
- Example1(const Example1 &e) : value(e.value) {
- cout << "Called Example1 copy constructor with value " << value << ".." << endl;
- }
- Example1(Example1 &&e) : value(e.value) {
- cout << "Called Example1 move constructor with value " << value << ".." << endl;
- e.value = 0;
- }
- ~Example1() {
- cout << "Called Example1 destructor (" << value << ")" << endl;
- }
- std::string toString() {
- return "Example1[value=" + std::to_string(value) + "]";
- }
-
- void operator=(const Example1 &e) { cout << "Assignment operator" << endl; value = e.value; }
- void operator=(Example1 &&e) { cout << "Move assignment operator" << endl; value = e.value; e.value = 0;}
-
- void add1(Example1 other) { value += other.value; } // passing by value
- void add2(Example1 &other) { value += other.value; } // passing by reference
- void add3(const Example1 &other) { value += other.value; } // passing by const reference
- void add4(Example1 *other) { value += other->value; } // passing by pointer
- void add5(const Example1 *other) { value += other->value; } // passing by const pointer
-
- void add6(int other) { value += other; } // passing by value
- void add7(int &other) { value += other; } // passing by reference
- void add8(const int &other) { value += other; } // passing by const reference
- void add9(int *other) { value += *other; } // passing by pointer
- void add10(const int *other) { value += *other; } // passing by const pointer
-
- Example1 self1() { return *this; } // return by value
- Example1 &self2() { return *this; } // return by reference
- const Example1 &self3() { return *this; } // return by const reference
- Example1 *self4() { return this; } // return by pointer
- const Example1 *self5() { return this; } // return by const pointer
-
- int internal1() { return value; } // return by value
- int &internal2() { return value; } // return by reference
- const int &internal3() { return value; } // return by const reference
- int *internal4() { return &value; } // return by pointer
- const int *internal5() { return &value; } // return by const pointer
-
- int value = 0;
-};
-
-void init_ex1(py::module &m) {
- py::class_<Example1>(m, "Example1")
- .def(py::init<>())
- .def(py::init<int>())
- .def(py::init<const Example1&>())
- .def("add1", &Example1::add1)
- .def("add2", &Example1::add2)
- .def("add3", &Example1::add3)
- .def("add4", &Example1::add4)
- .def("add5", &Example1::add5)
- .def("add6", &Example1::add6)
- .def("add7", &Example1::add7)
- .def("add8", &Example1::add8)
- .def("add9", &Example1::add9)
- .def("add10", &Example1::add10)
- .def("self1", &Example1::self1)
- .def("self2", &Example1::self2)
- .def("self3", &Example1::self3)
- .def("self4", &Example1::self4)
- .def("self5", &Example1::self5)
- .def("internal1", &Example1::internal1)
- .def("internal2", &Example1::internal2)
- .def("internal3", &Example1::internal3)
- .def("internal4", &Example1::internal4)
- .def("internal5", &Example1::internal5)
- .def("__str__", &Example1::toString)
- .def_readwrite("value", &Example1::value);
-}
diff --git a/example/example1.ref b/example/example1.ref
deleted file mode 100644
index 2c242f9..0000000
--- a/example/example1.ref
+++ /dev/null
@@ -1,26 +0,0 @@
-Called Example1 default constructor..
-Called Example1 constructor with value 32..
-Called Example1 copy constructor with value 32..
-Called Example1 copy constructor with value 32..
-Called Example1 destructor (32)
-Called Example1 destructor (32)
-Instance 1: Example1[value=320]
-Instance 2: Example1[value=32]
-Called Example1 copy constructor with value 320..
-Called Example1 move constructor with value 320..
-Called Example1 destructor (0)
-Example1[value=320]
-Called Example1 destructor (320)
-Example1[value=320]
-Example1[value=320]
-Example1[value=320]
-Example1[value=320]
-320
-320
-320
-320
-320
-Instance 1, direct access = 320
-Instance 1: Example1[value=100]
-Called Example1 destructor (32)
-Called Example1 destructor (100)
diff --git a/example/example12.cpp b/example/example12.cpp
deleted file mode 100644
index e5555f5..0000000
--- a/example/example12.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-/*
- example/example12.cpp -- overriding virtual functions from Python
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "example.h"
-#include <pybind11/functional.h>
-
-/* This is an example class that we'll want to be able to extend from Python */
-class Example12 {
-public:
- Example12(int state) : state(state) {
- cout << "Constructing Example12.." << endl;
- }
-
- ~Example12() {
- cout << "Destructing Example12.." << endl;
- }
-
- virtual int run(int value) {
- std::cout << "Original implementation of Example12::run(state=" << state
- << ", value=" << value << ")" << std::endl;
- return state + value;
- }
-
- virtual bool run_bool() = 0;
- virtual void pure_virtual() = 0;
-private:
- int state;
-};
-
-/* This is a wrapper class that must be generated */
-class PyExample12 : public Example12 {
-public:
- using Example12::Example12; /* Inherit constructors */
-
- virtual int run(int value) {
- /* Generate wrapping code that enables native function overloading */
- PYBIND11_OVERLOAD(
- int, /* Return type */
- Example12, /* Parent class */
- run, /* Name of function */
- value /* Argument(s) */
- );
- }
-
- virtual bool run_bool() {
- PYBIND11_OVERLOAD_PURE(
- bool, /* Return type */
- Example12, /* Parent class */
- run_bool, /* Name of function */
- /* This function has no arguments. The trailing comma
- in the previous line is needed for some compilers */
- );
- }
-
- virtual void pure_virtual() {
- PYBIND11_OVERLOAD_PURE(
- void, /* Return type */
- Example12, /* Parent class */
- pure_virtual, /* Name of function */
- /* This function has no arguments. The trailing comma
- in the previous line is needed for some compilers */
- );
- }
-};
-
-int runExample12(Example12 *ex, int value) {
- return ex->run(value);
-}
-
-bool runExample12Bool(Example12* ex) {
- return ex->run_bool();
-}
-
-void runExample12Virtual(Example12 *ex) {
- ex->pure_virtual();
-}
-
-void init_ex12(py::module &m) {
- /* Important: indicate the trampoline class PyExample12 using the third
- argument to py::class_. The second argument with the unique pointer
- is simply the default holder type used by pybind11. */
- py::class_<Example12, std::unique_ptr<Example12>, PyExample12>(m, "Example12")
- .def(py::init<int>())
- /* Reference original class in function definitions */
- .def("run", &Example12::run)
- .def("run_bool", &Example12::run_bool)
- .def("pure_virtual", &Example12::pure_virtual);
-
- m.def("runExample12", &runExample12);
- m.def("runExample12Bool", &runExample12Bool);
- m.def("runExample12Virtual", &runExample12Virtual);
-}
diff --git a/example/example12.py b/example/example12.py
deleted file mode 100644
index eb17523..0000000
--- a/example/example12.py
+++ /dev/null
@@ -1,36 +0,0 @@
-#!/usr/bin/env python
-from __future__ import print_function
-import sys
-sys.path.append('.')
-
-from example import Example12, runExample12, runExample12Virtual, runExample12Bool
-
-
-class ExtendedExample12(Example12):
- def __init__(self, state):
- super(ExtendedExample12, self).__init__(state + 1)
- self.data = "Hello world"
-
- def run(self, value):
- print('ExtendedExample12::run(%i), calling parent..' % value)
- return super(ExtendedExample12, self).run(value + 1)
-
- def run_bool(self):
- print('ExtendedExample12::run_bool()')
- return False
-
- def pure_virtual(self):
- print('ExtendedExample12::pure_virtual(): %s' % self.data)
-
-
-ex12 = Example12(10)
-print(runExample12(ex12, 20))
-try:
- runExample12Virtual(ex12)
-except Exception as e:
- print("Caught expected exception: " + str(e))
-
-ex12p = ExtendedExample12(10)
-print(runExample12(ex12p, 20))
-print(runExample12Bool(ex12p))
-runExample12Virtual(ex12p)
diff --git a/example/example12.ref b/example/example12.ref
deleted file mode 100644
index a25023f..0000000
--- a/example/example12.ref
+++ /dev/null
@@ -1,13 +0,0 @@
-Constructing Example12..
-Original implementation of Example12::run(state=10, value=20)
-30
-Caught expected exception: Tried to call pure virtual function "Example12::pure_virtual"
-Constructing Example12..
-ExtendedExample12::run(20), calling parent..
-Original implementation of Example12::run(state=11, value=21)
-32
-ExtendedExample12::run_bool()
-False
-ExtendedExample12::pure_virtual(): Hello world
-Destructing Example12..
-Destructing Example12..
diff --git a/example/example16.cpp b/example/example16.cpp
deleted file mode 100644
index 7b676a9..0000000
--- a/example/example16.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- example/example16.cpp -- automatic upcasting for polymorphic types
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "example.h"
-
-struct BaseClass { virtual ~BaseClass() {} };
-struct DerivedClass1 : BaseClass { };
-struct DerivedClass2 : BaseClass { };
-
-void init_ex16(py::module &m) {
- py::class_<BaseClass>(m, "BaseClass").def(py::init<>());
- py::class_<DerivedClass1>(m, "DerivedClass1").def(py::init<>());
- py::class_<DerivedClass2>(m, "DerivedClass2").def(py::init<>());
-
- m.def("return_class_1", []() -> BaseClass* { return new DerivedClass1(); });
- m.def("return_class_2", []() -> BaseClass* { return new DerivedClass2(); });
- m.def("return_none", []() -> BaseClass* { return nullptr; });
-}
diff --git a/example/example18.py b/example/example18.py
deleted file mode 100644
index 314e64d..0000000
--- a/example/example18.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from example import example18
-
-example18()
-
-
diff --git a/example/example4.py b/example/example4.py
deleted file mode 100755
index 37d952f..0000000
--- a/example/example4.py
+++ /dev/null
@@ -1,58 +0,0 @@
-#!/usr/bin/env python
-from __future__ import print_function
-import sys
-sys.path.append('.')
-
-from example import test_function
-from example import some_constant
-from example import EMyEnumeration
-from example import EFirstEntry
-from example import Example4
-from example import return_bytes
-from example import print_bytes
-
-print(EMyEnumeration)
-print(EMyEnumeration.EFirstEntry)
-print(EMyEnumeration.ESecondEntry)
-print(EFirstEntry)
-
-print(test_function())
-print(test_function(7))
-print(test_function(EMyEnumeration.EFirstEntry))
-print(test_function(EMyEnumeration.ESecondEntry))
-print("enum->integer = %i" % int(EMyEnumeration.ESecondEntry))
-print("integer->enum = %s" % str(EMyEnumeration(2)))
-
-print("A constant = " + str(some_constant))
-
-print(Example4.EMode)
-print(Example4.EMode.EFirstMode)
-print(Example4.EFirstMode)
-Example4.test_function(Example4.EFirstMode)
-
-print("Equality test 1: " + str(
- Example4.test_function(Example4.EFirstMode) ==
- Example4.test_function(Example4.EFirstMode)))
-
-print("Inequality test 1: " + str(
- Example4.test_function(Example4.EFirstMode) !=
- Example4.test_function(Example4.EFirstMode)))
-
-print("Equality test 2: " + str(
- Example4.test_function(Example4.EFirstMode) ==
- Example4.test_function(Example4.ESecondMode)))
-
-print("Inequality test 2: " + str(
- Example4.test_function(Example4.EFirstMode) !=
- Example4.test_function(Example4.ESecondMode)))
-
-x = {
- Example4.test_function(Example4.EFirstMode): 1,
- Example4.test_function(Example4.ESecondMode): 2
-}
-
-x[Example4.test_function(Example4.EFirstMode)] = 3
-x[Example4.test_function(Example4.ESecondMode)] = 4
-print("Hashing test = " + str(x))
-
-print_bytes(return_bytes())
diff --git a/example/example4.ref b/example/example4.ref
deleted file mode 100644
index a21f62c..0000000
--- a/example/example4.ref
+++ /dev/null
@@ -1,40 +0,0 @@
-<class 'example.EMyEnumeration'>
-EMyEnumeration.EFirstEntry
-EMyEnumeration.ESecondEntry
-EMyEnumeration.EFirstEntry
-test_function()
-False
-test_function(7)
-3.5
-test_function(enum=1)
-None
-test_function(enum=2)
-None
-enum->integer = 2
-integer->enum = EMyEnumeration.ESecondEntry
-A constant = 14
-<class 'example.EMode'>
-EMode.EFirstMode
-EMode.EFirstMode
-Example4::test_function(enum=1)
-Example4::test_function(enum=1)
-Example4::test_function(enum=1)
-Equality test 1: True
-Example4::test_function(enum=1)
-Example4::test_function(enum=1)
-Inequality test 1: False
-Example4::test_function(enum=1)
-Example4::test_function(enum=2)
-Equality test 2: False
-Example4::test_function(enum=1)
-Example4::test_function(enum=2)
-Inequality test 2: True
-Example4::test_function(enum=1)
-Example4::test_function(enum=2)
-Example4::test_function(enum=1)
-Example4::test_function(enum=2)
-Hashing test = {EMode.EFirstMode: 3, EMode.ESecondMode: 4}
-bytes[0]=1
-bytes[1]=0
-bytes[2]=2
-bytes[3]=0
diff --git a/example/run_test.py b/example/run_test.py
index 90fec06..e317028 100755
--- a/example/run_test.py
+++ b/example/run_test.py
@@ -24,7 +24,7 @@
line = line.replace('__builtin__', 'builtins')
line = line.replace('example.', '')
line = line.replace('unicode', 'str')
- line = line.replace('Example4.EMode', 'EMode')
+ line = line.replace('ExampleWithEnum.EMode', 'EMode')
line = line.replace('example.EMode', 'EMode')
line = line.replace('method of builtins.PyCapsule instance', '')
line = line.strip()