Straggler modules and enums

Author: arahlin

core/src/G3EventBuilder.cxx

@@ -104,10 +104,6 @@ void G3EventBuilder::ProcessThread(G3EventBuilder *builder)
 	}
 }
 
-
 PYBINDINGS("core", scope) {
-	py::class_<G3EventBuilder, py::bases<G3Module>, G3EventBuilderPtr,
-	  boost::noncopyable>("G3EventBuilder", py::no_init)
-	;
-}
-
+	register_g3module<G3EventBuilder>(scope, "G3EventBuilder");
+};

core/src/G3MultiFileWriter.cxx

@@ -162,31 +162,29 @@ void G3MultiFileWriter::Process(G3FramePtr frame, std::deque<G3FramePtr> &out)
 }
 
 PYBINDINGS("core", scope) {
-	py::class_<G3MultiFileWriter, py::bases<G3Module>, std::shared_ptr<G3MultiFileWriter>,
-	    boost::noncopyable>("G3MultiFileWriter",
-	      "Writes frames to disk into a sequence of files. Once a file exceeds "
-	      "the number of bytes specified in size_limit, it will start a new file. "
-	      "Files are named based on filename. If passed a string for filename "
-	      "with a printf-style specifier, that specifier will be replaced by a "
-	      "zero-indexed sequence number. For example, outfile-%03u.g3.gz would "
-	      "produce a sequence of files named outfile-000.g3.gz, outfile-001.g3.gz, "
-	      "etc. Alternatively, you can pass a callable that is passed the first "
-	      "frame in the new file and the sequence number and returns a path to "
-	      "the new file. Any frames besides Timepoint and Scan frames have the "
-	      "most recent frame of each type prepended to all new files.\n\n"
-	      "More complex behavior can be obtained with the optional divide_on "
-	      "argument. This can be an iterable of frame types (e.g. "
-	      "[core.G3FrameType.Observation]) or a callable. In the iterable case, "
-	      "the presence of any frame with a type in the list will cause the "
-	      "creation of a new file even if the file size threshold has not yet "
-	      "been met. This is useful to create files based on, for example, "
-	      "observation boundaries. For more flexibility, you can also pass a "
-	      "python callable as divide_on. This callable will be passed each "
-	      "frame in turn. If it returns True (or something with positive "
-	      "truth-value), a new file will be started at that frame.",
-	py::init<py::object, size_t, py::optional<py::object, size_t> >((py::arg("filename"),
-	    py::arg("size_limit"), py::arg("divide_on")=py::object(), py::arg("buffersize")=1024*1024)))
-	.def_readonly("current_file", &G3MultiFileWriter::CurrentFile)
-	.def_readonly("__g3module__", true)
-	;
+	register_g3module<G3MultiFileWriter>(scope, "G3MultiFileWriter",
+	    "Writes frames to disk into a sequence of files. Once a file exceeds "
+	    "the number of bytes specified in size_limit, it will start a new file. "
+	    "Files are named based on filename. If passed a string for filename "
+	    "with a printf-style specifier, that specifier will be replaced by a "
+	    "zero-indexed sequence number. For example, outfile-%03u.g3.gz would "
+	    "produce a sequence of files named outfile-000.g3.gz, outfile-001.g3.gz, "
+	    "etc. Alternatively, you can pass a callable that is passed the first "
+	    "frame in the new file and the sequence number and returns a path to "
+	    "the new file. Any frames besides Timepoint and Scan frames have the "
+	    "most recent frame of each type prepended to all new files.\n\n"
+	    "More complex behavior can be obtained with the optional divide_on "
+	    "argument. This can be an iterable of frame types (e.g. "
+	    "[core.G3FrameType.Observation]) or a callable. In the iterable case, "
+	    "the presence of any frame with a type in the list will cause the "
+	    "creation of a new file even if the file size threshold has not yet "
+	    "been met. This is useful to create files based on, for example, "
+	    "observation boundaries. For more flexibility, you can also pass a "
+	    "python callable as divide_on. This callable will be passed each "
+	    "frame in turn. If it returns True (or something with positive "
+            "truth-value), a new file will be started at that frame.")
+	.def(py::init<py::object, size_t, py::object, size_t>((py::arg("filename"),
+	    py::arg("size_limit"), py::arg("divide_on")=py::object(),
+	    py::arg("buffersize")=1024*1024)))
+	.def_readonly("current_file", &G3MultiFileWriter::CurrentFile);
 }

core/src/G3Reader.cxx

@@ -109,21 +109,19 @@ off_t G3Reader::Tell() {
 }
 
 PYBINDINGS("core", scope) {
-	// Instead of EXPORT_G3MODULE since there are two constructors
-	py::class_<G3Reader, py::bases<G3Module>, std::shared_ptr<G3Reader>,
-	    boost::noncopyable>("G3Reader",
-	      "Read frames from disk. Takes either the path to a file to read "
-	      "or an iterable of files to be read in sequence. If "
-	      "n_frames_to_read is greater than zero, will stop after "
-	      "n_frames_to_read frames rather than at the end of the file[s]. "
-	      "The timeout parameter can used to enable socket timeout for tcp "
-	      "streams, resulting in EOF behavior on expiry; unfortunately this "
-	      "cannot be used for polling, you have to close the connection. "
-	      "Use the `tell` and `seek` methods to record the position of and "
-	      "seek to the beginning of a particular frame in the file.  Set "
-	      "track_filename to True to record the filename for each frame in "
-	      "the ._filename attribute (fragile).",
-	py::init<std::string, int, float, bool, size_t>((py::arg("filename"),
+	register_g3module<G3Reader>(scope, "G3Reader",
+	    "Read frames from disk. Takes either the path to a file to read "
+	    "or an iterable of files to be read in sequence. If "
+	    "n_frames_to_read is greater than zero, will stop after "
+	    "n_frames_to_read frames rather than at the end of the file[s]. "
+	    "The timeout parameter can used to enable socket timeout for tcp "
+	    "streams, resulting in EOF behavior on expiry; unfortunately this "
+	    "cannot be used for polling, you have to close the connection. "
+	    "Use the `tell` and `seek` methods to record the position of and "
+	    "seek to the beginning of a particular frame in the file.  Set "
+	    "track_filename to True to record the filename for each frame in "
+	    "the ._filename attribute (fragile).")
+	.def(py::init<std::string, int, float, bool, size_t>((py::arg("filename"),
 	    py::arg("n_frames_to_read")=0, py::arg("timeout")=-1.,
 	    py::arg("track_filename")=false, py::arg("buffersize")=1024*1024)))
 	.def(py::init<std::vector<std::string>, int, float, bool, size_t>((
@@ -133,8 +131,6 @@ PYBINDINGS("core", scope) {
 	    "Return the current byte offset from start of stream.")
 	.def("seek", &G3Reader::Seek,
 	    "Position the stream read pointer at specific byte offset. "
-	    "Note that once EOF is reached, seek does not work anymore.")
-	.def_readonly("__g3module__", true)
-	;
+	    "Note that once EOF is reached, seek does not work anymore.");
 }
 

core/src/G3Writer.cxx

@@ -40,20 +40,17 @@ off_t G3Writer::Tell() {
 }
 
 PYBINDINGS("core", scope) {
-	// Instead of EXPORT_G3MODULE since there is an extra Flush function
-	py::class_<G3Writer, py::bases<G3Module>, std::shared_ptr<G3Writer>,
-	    boost::noncopyable>("G3Writer",
-	      "Writes frames to disk. Frames will be written to the file specified by "
-	      "filename. If filename ends in .gz, output will be compressed using gzip. "
-	      "To write only some types of frames, pass a list of the desired frame "
-	      "types to the second optional argument (streams). If no streams argument "
-	      "is given, writes all types of frames. If append is set to True, will "
-	      "append frames to its output file rather than overwriting it.",
-	py::init<std::string, std::vector<G3Frame::FrameType>, bool, size_t>((py::arg("filename"),
-	    py::arg("streams")=std::vector<G3Frame::FrameType>(), py::arg("append")=false,
-	    py::arg("buffersize")=1024*1024)))
-	.def("flush", &G3Writer::Flush)
-	.def("tell", &G3Writer::Tell)
-	.def_readonly("__g3module__", true)
+	register_g3module<G3Writer>(scope, "G3Writer",
+	    "Writes frames to disk. Frames will be written to the file specified by "
+	    "filename. If filename ends in .gz, output will be compressed using gzip. "
+	    "To write only some types of frames, pass a list of the desired frame "
+	    "types to the second optional argument (streams). If no streams argument "
+	    "is given, writes all types of frames. If append is set to True, will "
+	    "append frames to its output file rather than overwriting it.")
+	    .def(py::init<std::string, std::vector<G3Frame::FrameType>, bool, size_t>((
+	        py::arg("filename"), py::arg("streams")=std::vector<G3Frame::FrameType>(),
+	        py::arg("append")=false, py::arg("buffersize")=1024*1024)))
+	    .def("flush", &G3Writer::Flush)
+	    .def("tell", &G3Writer::Tell)
 	;
 }

gcp/src/ACUStatus.cxx

@@ -69,7 +69,7 @@ static bool operator == (const ACUStatus &a, const ACUStatus &b) {
 }
 
 PYBINDINGS("gcp", scope) {
-	py::enum_<enum ACUStatus::ACUState>("ACUState")
+	register_enum<ACUStatus::ACUState>(scope, "ACUState")
 	    .value("IDLE", ACUStatus::IDLE)
 	    .value("TRACKING", ACUStatus::TRACKING)
 	    .value("WAIT_RESTART", ACUStatus::WAIT_RESTART)

gcp/src/ARCFileReader.cxx

@@ -860,20 +860,19 @@ PYBINDINGS("gcp", scope) {
 	;
 
 	// Instead of EXPORT_G3MODULE since there are two constructors
-	py::class_<ARCFileReader, py::bases<G3Module>, std::shared_ptr<ARCFileReader>,
-	    boost::noncopyable>("ARCFileReader",
+	register_g3module<ARCFileReader>(scope, "ARCFileReader",
 	    "Read GCP archive file (or files if you pass an iterable of paths). "
 	    "For non-SPT ARC file formats, please set Experiment to the "
 	    "appropriate value.  Set track_filename to True to record the "
-	    "filename for each frame in the ._filename attribute (fragile).",
-		py::init<std::string, Experiment, float, bool, size_t>((py::arg("filename"),
-			py::arg("experiment")=Experiment::SPT, py::arg("timeout")=-1.,
-			py::arg("track_filename")=false, py::arg("buffersize")=1024*1024)))
-		.def(py::init<std::vector<std::string>, Experiment, float, bool, size_t>(
-			(py::arg("filename"), py::arg("experiment")=Experiment::SPT,
+	    "filename for each frame in the ._filename attribute (fragile).")
+		.def(py::init<std::string, Experiment, float, bool, size_t>((
+			py::arg("filename"), py::arg("experiment")=Experiment::SPT,
+			py::arg("timeout")=-1., py::arg("track_filename")=false,
+			py::arg("buffersize")=1024*1024)))
+		.def(py::init<std::vector<std::string>, Experiment, float, bool, size_t>((
+			py::arg("filename"), py::arg("experiment")=Experiment::SPT,
 			py::arg("timeout")=-1., py::arg("track_filename")=false,
 			py::arg("buffersize")=1024*1024)))
-		.def_readonly("__g3module__", true)
 	;
 }