pyxcp 0.23.3__cp312-cp312-win_arm64.whl → 0.25.6__cp312-cp312-win_arm64.whl

pyxcp/cpp_ext/daqlist.hpp

@@ -8,22 +8,70 @@
 
 using flatten_odts_t = std::vector<std::vector<std::tuple<std::string, std::uint32_t, std::uint8_t, std::uint16_t, std::int16_t>>>;
 
-class DaqList {
+class Odt {
    public:
+    using odt_entry_initializer_t = std::tuple<std::string, std::string>;
 
-    using daq_list_initialzer_t = std::tuple<std::string, std::uint32_t, std::uint16_t, std::string>;
+    Odt(const std::vector<odt_entry_initializer_t>& entries) {
+        for (const auto& entry : entries) {
+            const auto& [name, dt_name] = entry;
+            m_entries.emplace_back(McObject(name, 0, 0, 0, dt_name));
+        }
+    }
 
-    DaqList(
-        std::string_view meas_name, std::uint16_t event_num, bool stim, bool enable_timestamps,
-        const std::vector<daq_list_initialzer_t>& measurements, std::uint8_t priority=0x00, std::uint8_t prescaler=0x01
-    ) :
-        m_name(meas_name), m_event_num(event_num), m_priority(priority), m_prescaler(prescaler), m_stim(stim), m_enable_timestamps(enable_timestamps) {
-        for (const auto& measurement : measurements) {
-            auto const& [name, address, ext, dt_name] = measurement;
-            m_measurements.emplace_back(McObject(name, address, static_cast<std::uint8_t>(ext), 0, dt_name));
+    const std::vector<McObject>& get_entries() const {
+        return m_entries;
+    }
+
+    std::string dumps() const {
+        std::stringstream ss;
+        ss << to_binary(m_entries.size());
+        for (const auto& entry : m_entries) {
+            ss << entry.dumps();
         }
+        return ss.str();
     }
 
+    std::string to_string() const {
+        std::stringstream ss;
+        ss << "Odt(entries=[";
+        for (std::size_t i = 0; i < m_entries.size(); ++i) {
+            ss << ::to_string(m_entries[i]);
+            if (i + 1 < m_entries.size()) {
+                ss << ", ";
+            }
+        }
+        ss << "])";
+        return ss.str();
+    }
+
+   private:
+    std::vector<McObject> m_entries;
+};
+
+inline std::string to_string(const Odt& odt) {
+    return odt.to_string();
+}
+
+class DaqListBase {
+   public:
+    DaqListBase(std::string_view name, std::uint16_t event_num, bool stim, bool enable_timestamps, std::uint8_t priority, std::uint8_t prescaler) :
+        m_name(name),
+        m_event_num(event_num),
+        m_priority(priority),
+        m_prescaler(prescaler),
+        m_stim(stim),
+        m_enable_timestamps(enable_timestamps),
+        m_odt_count(0),
+        m_total_entries(0),
+        m_total_length(0) {
+    }
+
+    virtual ~DaqListBase() = default;
+
+    virtual std::string dumps() const = 0;
+    virtual std::string to_string() const = 0;
+
     bool get_enable_timestamps() const {
         return m_enable_timestamps;
     }
@@ -52,10 +100,6 @@ class DaqList {
         return m_stim;
     }
 
-    const std::vector<McObject>& get_measurements() const {
-        return m_measurements;
-    }
-
     const std::vector<Bin>& get_measurements_opt() const {
         return m_measurements_opt;
     }
@@ -86,6 +130,10 @@ class DaqList {
 
     void set_measurements_opt(const std::vector<Bin>& measurements_opt) {
         m_measurements_opt = measurements_opt;
+        m_header_names.clear();
+        m_headers.clear();
+        m_flatten_odts.clear();
+
         auto odt_count     = 0u;
         auto total_entries = 0u;
         auto total_length  = 0u;
@@ -93,31 +141,85 @@ class DaqList {
             odt_count++;
             std::vector<std::tuple<std::string, std::uint32_t, std::uint8_t, std::uint16_t, std::int16_t>> flatten_odt{};
             for (const auto& mc_obj : bin.get_entries()) {
-                for (const auto& component : mc_obj.get_components()) {
-                    m_header_names.emplace_back(component.get_name());
+                const auto& components = mc_obj.get_components();
+                if (!components.empty()) {
+                    for (const auto& component : components) {
+                        m_header_names.emplace_back(component.get_name());
+                        flatten_odt.emplace_back(
+                            component.get_name(), component.get_address(), component.get_ext(), component.get_length(),
+                            component.get_type_index()
+                        );
+                        // TYPE_MAP_REV::at may throw if key is invalid; this indicates a programming error upstream.
+                        m_headers.emplace_back(component.get_name(), TYPE_MAP_REV.at(static_cast<std::uint16_t>(component.get_type_index())));
+                        total_entries++;
+                        total_length += component.get_length();
+                    }
+                } else {
+                    // Treat the McObject itself as an entry when it has no components.
+                    m_header_names.emplace_back(mc_obj.get_name());
                     flatten_odt.emplace_back(
-                        component.get_name(), component.get_address(), component.get_ext(), component.get_length(),
-                        component.get_type_index()
+                        mc_obj.get_name(), mc_obj.get_address(), mc_obj.get_ext(), mc_obj.get_length(), mc_obj.get_type_index()
                     );
-                    m_headers.emplace_back(component.get_name(), TYPE_MAP_REV.at(component.get_type_index()));
+                    m_headers.emplace_back(mc_obj.get_name(), TYPE_MAP_REV.at(static_cast<std::uint16_t>(mc_obj.get_type_index())));
                     total_entries++;
-                    total_length += component.get_length();
+                    total_length += mc_obj.get_length();
                 }
             }
-            m_flatten_odts.emplace_back(flatten_odt);
+            m_flatten_odts.emplace_back(std::move(flatten_odt));
         }
-        m_odt_count     = odt_count;
-        m_total_entries = total_entries;
-        m_total_length  = total_length;
+        m_odt_count     = static_cast<std::uint16_t>(odt_count);
+        m_total_entries = static_cast<std::uint16_t>(total_entries);
+        m_total_length  = static_cast<std::uint16_t>(total_length);
     }
 
-    std::string dumps() const {
+   protected:
+    std::string                                       m_name;
+    std::uint16_t                                     m_event_num;
+    std::uint8_t                                      m_priority;
+    std::uint8_t                                      m_prescaler;
+    bool                                              m_stim;
+    bool                                              m_enable_timestamps;
+    std::vector<Bin>                                  m_measurements_opt;
+    std::vector<std::string>                          m_header_names;
+    std::vector<std::tuple<std::string, std::string>> m_headers;
+    std::uint16_t                                     m_odt_count;
+    std::uint16_t                                     m_total_entries;
+    std::uint16_t                                     m_total_length;
+    flatten_odts_t                                    m_flatten_odts;
+};
+
+class DaqList : public DaqListBase {
+   public:
+
+    using daq_list_initialzer_t = std::tuple<std::string, std::uint32_t, std::uint16_t, std::string>;
+
+    DaqList(
+        std::string_view meas_name, std::uint16_t event_num, bool stim, bool enable_timestamps,
+        const std::vector<daq_list_initialzer_t>& measurements, std::uint8_t priority=0x00, std::uint8_t prescaler=0x01
+    ) :
+        DaqListBase(meas_name, event_num, stim, enable_timestamps, priority, prescaler) {
+        for (const auto& measurement : measurements) {
+            auto const& [name, address, ext, dt_name] = measurement;
+            m_measurements.emplace_back(McObject(name, address, static_cast<std::uint8_t>(ext), 0, dt_name));
+        }
+    }
+
+    const std::vector<McObject>& get_measurements() const {
+        return m_measurements;
+    }
+
+    std::string dumps() const override {
         std::stringstream ss;
 
+		std::uint8_t discr=1;
+
+        ss << to_binary(discr);
         ss << to_binary(m_name);
         ss << to_binary(m_event_num);
         ss << to_binary(m_stim);
         ss << to_binary(m_enable_timestamps);
+        ss << to_binary(m_priority);
+        ss << to_binary(m_prescaler);
 
         ss << to_binary(m_odt_count);
         ss << to_binary(m_total_entries);
@@ -138,47 +240,39 @@ class DaqList {
         for (const auto& hdr_obj : m_header_names) {
             ss << to_binary(hdr_obj);
         }
-        /////
-        std::size_t odt_size = m_flatten_odts.size();
-        ss << to_binary(odt_size);
-        for (const auto& odt : m_flatten_odts) {
-            ss << to_binary(odt.size());
-            for (const auto& odt_entry : odt) {
-                const auto& [name, address, ext, size, type_index] = odt_entry;
-                ss << to_binary(name);
-                ss << to_binary(address);
-                ss << to_binary(ext);
-                ss << to_binary(size);
-                ss << to_binary(type_index);
-            }
-        }
         return ss.str();
     }
 
-    std::string to_string() const {
+    std::string to_string() const override {
         std::stringstream ss;
-
         ss << "DaqList(";
-        ss << "name=\"" << m_name << "\", ";
+        ss << "name='" << m_name << "', ";
         ss << "event_num=" << static_cast<std::uint16_t>(m_event_num) << ", ";
         ss << "stim=" << bool_to_string(m_stim) << ", ";
-        ss << "enable_timestamps" << bool_to_string(m_enable_timestamps) << ", ";
-        ss << "measurements=[\n";
-        for (const auto& meas : m_measurements) {
-            ss << ::to_string(meas) << ",\n";
-        }
-        ss << "],\n";
-        ss << "measurements_opt=[\n";
-        for (const auto& meas : m_measurements_opt) {
-            ss << ::to_string(meas) << ",\n";
-        }
-        ss << "],\n";
-        ss << "header_names=[\n";
-        for (const auto& header : m_header_names) {
-            ss << "\"" << header << "\",";
-        }
-        ss << "\n]";
-        ss << ")";
+        ss << "enable_timestamps=" << bool_to_string(m_enable_timestamps) << ", ";
+        ss << "priority=" << static_cast<std::uint16_t>(m_priority) << ", ";
+        ss << "prescaler=" << static_cast<std::uint16_t>(m_prescaler) << ", ";
+        ss << "odt_count=" << static_cast<std::uint16_t>(m_odt_count) << ", ";
+        ss << "total_entries=" << static_cast<std::uint16_t>(m_total_entries) << ", ";
+        ss << "total_length=" << static_cast<std::uint16_t>(m_total_length) << ", ";
+        ss << "measurements=[";
+        for (std::size_t i = 0; i < m_measurements.size(); ++i) {
+            ss << ::to_string(m_measurements[i]);
+            if (i + 1 < m_measurements.size()) ss << ", ";
+        }
+        ss << "], ";
+        ss << "measurements_opt=[";
+        for (std::size_t i = 0; i < m_measurements_opt.size(); ++i) {
+            ss << ::to_string(m_measurements_opt[i]);
+            if (i + 1 < m_measurements_opt.size()) ss << ", ";
+        }
+        ss << "], ";
+        ss << "header_names=[";
+        for (std::size_t i = 0; i < m_header_names.size(); ++i) {
+            ss << "'" << m_header_names[i] << "'";
+            if (i + 1 < m_header_names.size()) ss << ", ";
+        }
+        ss << "])";
         return ss.str();
     }
 
@@ -186,21 +280,95 @@ class DaqList {
     }
 
    private:
+    std::vector<McObject> m_measurements;
+};
 
-    std::string                                       m_name;
-    std::uint16_t                                     m_event_num;
-    std::uint8_t                                      m_priority;
-    std::uint8_t                                      m_prescaler;
-    bool                                              m_stim;
-    bool                                              m_enable_timestamps;
-    std::vector<McObject>                             m_measurements;
-    std::vector<Bin>                                  m_measurements_opt;
-    std::vector<std::string>                          m_header_names;
-    std::vector<std::tuple<std::string, std::string>> m_headers;
-    std::uint16_t                                     m_odt_count;
-    std::uint16_t                                     m_total_entries;
-    std::uint16_t                                     m_total_length;
-    flatten_odts_t                                    m_flatten_odts;
+class PredefinedDaqList : public DaqListBase {
+   public:
+    using odt_initializer_t = std::vector<Odt::odt_entry_initializer_t>;
+    using predefined_daq_list_initializer_t = std::vector<odt_initializer_t>;
+
+    PredefinedDaqList(
+        std::string_view name, std::uint16_t event_num, bool stim, bool enable_timestamps,
+        const predefined_daq_list_initializer_t& odts, std::uint8_t priority = 0x00, std::uint8_t prescaler = 0x01) :
+        DaqListBase(name, event_num, stim, enable_timestamps, priority, prescaler) {
+        std::vector<Bin> bins;
+        bins.reserve(odts.size());
+        for (const auto& odt_init : odts) {
+            Bin bin(0);
+            std::uint16_t total_length = 0;
+            for (const auto& entry : odt_init) {
+                const auto& [name, dt_name] = entry;
+                // McObject will validate dt_name and set length accordingly.
+                McObject obj(name, 0, 0, 0, dt_name);
+                total_length = static_cast<std::uint16_t>(total_length + obj.get_length());
+                bin.append(obj);
+            }
+            // Derive Bin size and residual capacity from sum of entry lengths.
+            bin.set_size(total_length);
+            bin.set_residual_capacity(total_length);
+            bins.emplace_back(std::move(bin));
+        }
+        set_measurements_opt(bins);
+    }
+
+    std::string dumps() const override {
+        std::stringstream ss;
+
+		std::uint8_t discr=2;
+
+        ss <<  to_binary(discr);
+
+        ss << to_binary(m_name);
+        ss << to_binary(m_event_num);
+        ss << to_binary(m_stim);
+        ss << to_binary(m_enable_timestamps);
+        ss << to_binary(m_priority);
+        ss << to_binary(m_prescaler);
+
+        ss << to_binary(m_odt_count);
+        ss << to_binary(m_total_entries);
+        ss << to_binary(m_total_length);
+
+        std::size_t meas_opt_size = m_measurements_opt.size();
+        ss << to_binary(meas_opt_size);
+        for (const auto& mc_obj : m_measurements_opt) {
+            ss << mc_obj.dumps();
+        }
+        std::size_t hname_size = m_header_names.size();
+        ss << to_binary(hname_size);
+        for (const auto& hdr_obj : m_header_names) {
+            ss << to_binary(hdr_obj);
+        }
+        return ss.str();
+    }
+
+    std::string to_string() const override {
+        std::stringstream ss;
+        ss << "PredefinedDaqList(";
+        ss << "name='" << m_name << "', ";
+        ss << "event_num=" << static_cast<std::uint16_t>(m_event_num) << ", ";
+        ss << "stim=" << bool_to_string(m_stim) << ", ";
+        ss << "enable_timestamps=" << bool_to_string(m_enable_timestamps) << ", ";
+        ss << "priority=" << static_cast<std::uint16_t>(m_priority) << ", ";
+        ss << "prescaler=" << static_cast<std::uint16_t>(m_prescaler) << ", ";
+        ss << "odt_count=" << static_cast<std::uint16_t>(m_odt_count) << ", ";
+        ss << "total_entries=" << static_cast<std::uint16_t>(m_total_entries) << ", ";
+        ss << "total_length=" << static_cast<std::uint16_t>(m_total_length) << ", ";
+        ss << "measurements_opt=[";
+        for (std::size_t i = 0; i < m_measurements_opt.size(); ++i) {
+            ss << ::to_string(m_measurements_opt[i]);
+            if (i + 1 < m_measurements_opt.size()) ss << ", ";
+        }
+        ss << "], ";
+        ss << "header_names=[";
+        for (std::size_t i = 0; i < m_header_names.size(); ++i) {
+            ss << "'" << m_header_names[i] << "'";
+            if (i + 1 < m_header_names.size()) ss << ", ";
+        }
+        ss << "])";
+        return ss.str();
+    }
 };
 
 #endif  // __DAQ_LIST_HPP

pyxcp/cpp_ext/extension_wrapper.cpp

@@ -4,9 +4,11 @@
 #include <pybind11/numpy.h>
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
+#include <memory>
 
 #include <cstdint>
 
+#include "aligned_buffer.hpp"
 #include "bin.hpp"
 #include "daqlist.hpp"
 #include "mcobject.hpp"
@@ -20,6 +22,22 @@ class PyTimestampInfo : public TimestampInfo {
     using TimestampInfo::TimestampInfo;
 };
 
+py::dict mcobject_asdict(const McObject& self) {
+    py::dict d;
+    d["name"] = self.get_name();
+    d["address"] = self.get_address();
+    d["ext"] = self.get_ext();
+    d["length"] = self.get_length();
+    d["data_type"] = self.get_data_type();
+    py::list components_list;
+    for (const auto& component : self.get_components()) {
+        components_list.append(mcobject_asdict(component));
+    }
+    d["components"] = components_list;
+    return d;
+}
+
+
 PYBIND11_MODULE(cpp_ext, m) {
     m.doc() = "C++ extensions for pyXCP.";
 
@@ -40,6 +58,7 @@ PYBIND11_MODULE(cpp_ext, m) {
         .def_property_readonly("components", &McObject::get_components)
 
         .def("add_component", &McObject::add_component, "component"_a)
+        .def("asdict", &mcobject_asdict)
         .def("__eq__", [](const McObject& self, const McObject& other) { return self == other; })
         .def("__repr__", [](const McObject& self) { return to_string(self); })
         .def("__hash__", [](const McObject& self) { return self.get_hash(); })
@@ -51,32 +70,120 @@ PYBIND11_MODULE(cpp_ext, m) {
         .def_property("residual_capacity", &Bin::get_residual_capacity, &Bin::set_residual_capacity)
         .def_property("entries", &Bin::get_entries, nullptr)
         .def("append", &Bin::append)
-
+        .def("asdict", [](const Bin& self) {
+            py::dict d;
+            d["size"] = self.get_size();
+            d["residual_capacity"] = self.get_residual_capacity();
+            py::list entries_list;
+            for (const auto& entry : self.get_entries()) {
+                entries_list.append(mcobject_asdict(entry));
+            }
+            d["entries"] = entries_list;
+            return d;
+        })
         .def("__repr__", [](const Bin& self) { return to_string(self); })
-
         .def("__eq__", [](const Bin& self, const Bin& other) { return self == other; })
-
         .def("__len__", [](const Bin& self) { return std::size(self.get_entries()); });
 
-    py::class_<DaqList>(m, "DaqList")
+    py::class_<DaqListBase, std::shared_ptr<DaqListBase>>(m, "DaqListBase")
+        .def_property("name", &DaqListBase::get_name, nullptr)
+        .def_property("event_num", &DaqListBase::get_event_num, &DaqListBase::set_event_num)
+        .def_property("priority", &DaqListBase::get_priority, nullptr)
+        .def_property("prescaler", &DaqListBase::get_prescaler, nullptr)
+        .def_property("stim", &DaqListBase::get_stim, nullptr)
+        .def_property("enable_timestamps", &DaqListBase::get_enable_timestamps, nullptr)
+        .def_property("measurements_opt", &DaqListBase::get_measurements_opt, &DaqListBase::set_measurements_opt)
+        .def_property("headers", &DaqListBase::get_headers, nullptr)
+        .def_property("odt_count", &DaqListBase::get_odt_count, nullptr)
+        .def_property("total_entries", &DaqListBase::get_total_entries, nullptr)
+        .def_property("total_length", &DaqListBase::get_total_length, nullptr)
+        .def("asdict", [](const DaqListBase& self) {
+            py::dict d;
+            d["name"] = self.get_name();
+            d["event_num"] = self.get_event_num();
+            d["priority"] = self.get_priority();
+            d["prescaler"] = self.get_prescaler();
+            d["stim"] = self.get_stim();
+            d["enable_timestamps"] = self.get_enable_timestamps();
+            d["measurements_opt"] = self.get_measurements_opt();
+            d["headers"] = self.get_headers();
+            d["odt_count"] = self.get_odt_count();
+            d["total_entries"] = self.get_total_entries();
+            d["total_length"] = self.get_total_length();
+            return d;
+        });
+
+    py::class_<DaqList, DaqListBase, std::shared_ptr<DaqList>>(m, "DaqList")
         .def(
             py::init<std::string_view, std::uint16_t, bool, bool, const std::vector<DaqList::daq_list_initialzer_t>&,
             std::uint8_t, std::uint8_t>(), "name"_a, "event_num"_a, "stim"_a, "enable_timestamps"_a, "measurements"_a,
             "priority"_a=0, "prescaler"_a=1
         )
         .def("__repr__", [](const DaqList& self) { return self.to_string(); })
-        .def_property("name", &DaqList::get_name, nullptr)
-        .def_property("event_num", &DaqList::get_event_num, &DaqList::set_event_num)
-        .def_property("priority", &DaqList::get_priority, nullptr)
-        .def_property("prescaler", &DaqList::get_prescaler, nullptr)
-        .def_property("stim", &DaqList::get_stim, nullptr)
-        .def_property("enable_timestamps", &DaqList::get_enable_timestamps, nullptr)
         .def_property("measurements", &DaqList::get_measurements, nullptr)
-        .def_property("measurements_opt", &DaqList::get_measurements_opt, &DaqList::set_measurements_opt)
-        .def_property("headers", &DaqList::get_headers, nullptr)
-        .def_property("odt_count", &DaqList::get_odt_count, nullptr)
-        .def_property("total_entries", &DaqList::get_total_entries, nullptr)
-        .def_property("total_length", &DaqList::get_total_length, nullptr);
+        .def("asdict", [](const DaqList& self) {
+            py::dict d;
+            d["name"] = self.get_name();
+            d["event_num"] = self.get_event_num();
+            d["priority"] = self.get_priority();
+            d["prescaler"] = self.get_prescaler();
+            d["stim"] = self.get_stim();
+            d["enable_timestamps"] = self.get_enable_timestamps();
+            d["measurements_opt"] = self.get_measurements_opt();
+            d["headers"] = self.get_headers();
+            d["odt_count"] = self.get_odt_count();
+            d["total_entries"] = self.get_total_entries();
+            d["total_length"] = self.get_total_length();
+            py::list measurements_list;
+            for (const auto& measurement : self.get_measurements()) {
+                measurements_list.append(mcobject_asdict(measurement));
+            }
+            d["measurements"] = measurements_list;
+            return d;
+        });
+
+    py::class_<PredefinedDaqList, DaqListBase, std::shared_ptr<PredefinedDaqList>>(m, "PredefinedDaqList")
+        .def(
+            py::init<std::string_view, std::uint16_t, bool, bool, const PredefinedDaqList::predefined_daq_list_initializer_t&,
+            std::uint8_t, std::uint8_t>(), "name"_a, "event_num"_a, "stim"_a, "enable_timestamps"_a, "odts"_a,
+            "priority"_a=0, "prescaler"_a=1
+        )
+        .def("__repr__", [](const PredefinedDaqList& self) {
+            try {
+                return self.to_string();
+            } catch (const std::exception& e) {
+                return std::string("PredefinedDaqList(<repr error: ") + e.what() + ">)";
+            } catch (...) {
+                return std::string("PredefinedDaqList(<repr error: unknown>)");
+            }
+        })
+        .def("asdict", [](const PredefinedDaqList& self) {
+            py::dict d;
+            d["name"] = self.get_name();
+            d["event_num"] = self.get_event_num();
+            d["priority"] = self.get_priority();
+            d["prescaler"] = self.get_prescaler();
+            d["stim"] = self.get_stim();
+            d["enable_timestamps"] = self.get_enable_timestamps();
+            d["measurements_opt"] = self.get_measurements_opt();
+            d["headers"] = self.get_headers();
+            d["odt_count"] = self.get_odt_count();
+            d["total_entries"] = self.get_total_entries();
+            d["total_length"] = self.get_total_length();
+            return d;
+        })
+		;
+
+    // Aligned buffer utility
+    py::class_<AlignedBuffer>(m, "AlignedBuffer")
+        .def(py::init<std::size_t>(), py::arg("size") = 0xffff)
+        .def("reset", &AlignedBuffer::reset)
+        .def("append", &AlignedBuffer::append, py::arg("value"))
+        .def("extend", py::overload_cast<const py::bytes&>(&AlignedBuffer::extend))
+        .def("extend", py::overload_cast<const std::vector<std::uint8_t>&>(&AlignedBuffer::extend))
+        .def("__len__", [](const AlignedBuffer& self) { return self.size(); })
+        .def("__getitem__", [](const AlignedBuffer& self, py::object index) { return self.get_item(index); });
+
 
     py::enum_<TimestampType>(m, "TimestampType")
         .value("ABSOLUTE_TS", TimestampType::ABSOLUTE_TS)
@@ -97,4 +204,5 @@ PYBIND11_MODULE(cpp_ext, m) {
         .def_property("utc_offset", &TimestampInfo::get_utc_offset, &TimestampInfo::set_utc_offset)
         .def_property("dst_offset", &TimestampInfo::get_dst_offset, &TimestampInfo::set_dst_offset)
         .def_property("timezone", &TimestampInfo::get_timezone, &TimestampInfo::set_timezone);
+
 }