lsst::afw::table::io::python Namespace Reference

Functions
template<typename T >
void	declarePersistableFacade (pybind11::module &module, std::string const &suffix)
	Wraps an instantiation of PersistableFacade. More...
template<typename Class , typename... Args>
void	addPersistableMethods (pybind11::class_< Class, Args... > &cls)
	Add table::io::Persistable and PersistableFacade methods to the pybind11 wrapper for a class. More...

Function Documentation

addPersistableMethods()

template<typename Class , typename... Args>

void lsst::afw::table::io::python::addPersistableMethods

(

pybind11::class_< Class, Args... > &

cls

)

Add table::io::Persistable and PersistableFacade methods to the pybind11 wrapper for a class.

Use this instead of declarePersistableFacade to avoid circular import issues in Python; it allows your class to be used without importing lsst.afw.table.

Use as follows:

• When declaring the pybind11 class that wraps your Class do not list table::io::PersistableFacade<Class> and table::io::Persistable as base classes.
• Call this function to wrap the methods that make your object persistable.

Definition at line 90 of file python.h.

                                                                {
    cls.def_static("readFits",
                   (std::shared_ptr<Class>(*)(std::string const &, int)) & PersistableFacade<Class>::readFits,
                   "fileName"_a, "hdu"_a = fits::DEFAULT_HDU);
    cls.def_static(
            "readFits",
            (std::shared_ptr<Class>(*)(fits::MemFileManager &, int)) & PersistableFacade<Class>::readFits,
            "manager"_a, "hdu"_a = fits::DEFAULT_HDU);
    cls.def("writeFits", (void (Class::*)(std::string const &, std::string const &) const) & Class::writeFits,
            "fileName"_a, "mode"_a = "w");
    cls.def("writeFits",
            (void (Class::*)(fits::MemFileManager &, std::string const &) const) & Class::writeFits,
            "manager"_a, "mode"_a = "w");
    cls.def("isPersistable", &Class::isPersistable);
}

declarePersistableFacade()

template<typename T >

void lsst::afw::table::io::python::declarePersistableFacade	(	pybind11::module &	module,
		std::string const &	suffix
	)

Wraps an instantiation of PersistableFacade.

Deprecated:

Use addPersistableMethods for all new code.

Pybind11 shall assume that PersistableFacade is managed using std::shared_ptr, as this is required for compatibility with existing subclasses of PersistableFacade. This means that wrapping will only work if new classes also use std::shared_ptr as their holder type.

Template Parameters

T	The type of object this PersistableFacade is for.

Parameters

module	The pybind11 module that shall contain PersistableFacade<T>
suffix	A string to disambiguate this class from other PersistableFacades. The Python name of this class shall be PersistableFacade<suffix>.

Definition at line 65 of file python.h.

                                                                                  {
    using namespace pybind11::literals;

    pybind11::class_<PersistableFacade<T>, std::shared_ptr<PersistableFacade<T>>> cls(
            module, ("PersistableFacade" + suffix).c_str());
    cls.def_static("readFits",
                   (std::shared_ptr<T>(*)(std::string const &, int)) & PersistableFacade<T>::readFits,
                   "fileName"_a, "hdu"_a = fits::DEFAULT_HDU);
    cls.def_static("readFits",
                   (std::shared_ptr<T>(*)(fits::MemFileManager &, int)) & PersistableFacade<T>::readFits,
                   "manager"_a, "hdu"_a = fits::DEFAULT_HDU);
}