From 72d69d3ec90c1e0a3565d475a092d0f2051bd776 Mon Sep 17 00:00:00 2001 From: John Wiegley Date: Wed, 8 Sep 2004 21:21:21 -0400 Subject: Python fixes; starting adding support for using item_handlers in python --- format.cc | 20 ++++++++++ journal.cc | 9 ++++- ledger.h | 7 ++++ main.py | 10 ++++- pyledger.cc | 4 ++ walk.cc | 122 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 170 insertions(+), 2 deletions(-) diff --git a/format.cc b/format.cc index d99f9824..e6086b44 100644 --- a/format.cc +++ b/format.cc @@ -431,3 +431,23 @@ bool format_account::display_account(const account_t& account, } } // namespace ledger + +#ifdef USE_BOOST_PYTHON + +#include + +using namespace boost::python; +using namespace ledger; + +void export_format() +{ +#if 0 + class_< format_transactions > ("FormatTransactions") + .def(init *>()) + .def("flush", &format_transactions::flush) + .def("__call__", &format_transactions::operator()); + ; +#endif +} + +#endif // USE_BOOST_PYTHON diff --git a/journal.cc b/journal.cc index 3806e411..b7d1d921 100644 --- a/journal.cc +++ b/journal.cc @@ -397,6 +397,11 @@ using namespace ledger; BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(journal_find_account_overloads, find_account, 1, 2) +entry_t& transaction_entry(const transaction_t& xact) +{ + return *xact.entry; +} + unsigned int transactions_len(entry_t& entry) { return entry.transactions.size(); @@ -504,7 +509,9 @@ void export_journal() class_< transaction_t > ("Transaction") .def(init >()) - .def_readwrite("entry", &transaction_t::entry) + .add_property("entry", + make_getter(&transaction_t::entry, + return_value_policy())) .def_readwrite("account", &transaction_t::account) .def_readwrite("amount", &transaction_t::amount) .def_readwrite("cost", &transaction_t::cost) diff --git a/ledger.h b/ledger.h index 1d64e4e1..c3ed47b3 100644 --- a/ledger.h +++ b/ledger.h @@ -62,6 +62,13 @@ class transaction_t delete cost; } +#ifdef USE_BOOST_PYTHON + entry_t& get_entry() const { + assert(entry); + return *entry; + } +#endif + bool valid() const; }; diff --git a/main.py b/main.py index 4103e5a3..0a0919ca 100644 --- a/main.py +++ b/main.py @@ -19,5 +19,13 @@ register_parser (parser) journal = Journal () parse_journal_file (args[0], journal) +class OutputTransaction (TransactionHandler): + def __call__ (self, xact): + print xact.entry.payee + +handler = OutputTransaction() +chain = FilterTransactions (handler, "/Checking/") + for entry in journal: - print entry.payee + for xact in entry: + chain (xact) diff --git a/pyledger.cc b/pyledger.cc index d469c2f3..55cf0f3a 100644 --- a/pyledger.cc +++ b/pyledger.cc @@ -17,6 +17,8 @@ void export_qif(); void export_gnucash(); #endif void export_option(); +void export_walk(); +void export_format(); BOOST_PYTHON_MODULE(ledger) { export_amount(); @@ -31,4 +33,6 @@ BOOST_PYTHON_MODULE(ledger) { export_gnucash(); #endif export_option(); + export_walk(); + export_format(); } diff --git a/walk.cc b/walk.cc index 61c3fa30..0e0fd0ab 100644 --- a/walk.cc +++ b/walk.cc @@ -300,3 +300,125 @@ void dow_transactions::flush() } } // namespace ledger + +#ifdef USE_BOOST_PYTHON + +#include + +using namespace boost::python; +using namespace ledger; + +template +struct item_handler_wrap : public item_handler +{ + PyObject* self; + item_handler_wrap(PyObject * self_) : self(self_) {} + item_handler_wrap(PyObject * self_, const item_handler& handler) + : item_handler(const_cast *>(&handler)), self(self_) {} + + void flush() { + call_method(self, "flush"); + } + void default_flush() { + item_handler::flush(); + } + + void operator()(T& item) { + call_method(self, "__call__", item); + } + void default_call(T& item) { + item_handler::operator()(item); + } +}; + +void (subtotal_transactions::*subtotal_transactions_flush)() = + &subtotal_transactions::flush; + +void export_walk() +{ + class_< item_handler, + item_handler_wrap > ("TransactionHandler") + .def(init *>()) + + .def("flush", &item_handler::flush, + &item_handler_wrap::default_flush) + .def("__call__", &item_handler::operator(), + &item_handler_wrap::default_call) + ; + + class_< ignore_transactions > ("IgnoreTransactions") + .def("flush", &item_handler::flush) + .def("__call__", &ignore_transactions::operator()); + ; + + class_< clear_transaction_data > ("ClearTransactionData") + .def("flush", &item_handler::flush) + .def("__call__", &clear_transaction_data::operator()); + ; + + class_< set_account_value > + ("SetAccountValue", init *>()) + .def("flush", &item_handler::flush) + .def("__call__", &set_account_value::operator()); + ; + +#if 0 + class_< sort_transactions > + ("SortTransactions", init *>()) + .def("flush", &sort_transactions::flush) + .def("__call__", &sort_transactions::operator()); + ; +#endif + + class_< filter_transactions > + ("FilterTransactions", init *, std::string>()) + .def("flush", &item_handler::flush) + .def("__call__", &filter_transactions::operator()); + ; + + class_< calc_transactions > + ("CalcTransactions", init *, optional >()) + .def("flush", &item_handler::flush) + .def("__call__", &calc_transactions::operator()); + ; + + class_< collapse_transactions > + ("CollapseTransactions", init *>()) + .def("flush", &collapse_transactions::flush) + .def("__call__", &collapse_transactions::operator()); + ; + + class_< changed_value_transactions > + ("ChangeValueTransactions", init *, bool>()) + .def("flush", &changed_value_transactions::flush) + .def("__call__", &changed_value_transactions::operator()); + ; + + class_< subtotal_transactions > + ("SubtotalTransactions", init *>()) + .def("flush", subtotal_transactions_flush) + .def("__call__", &subtotal_transactions::operator()); + ; + +#if 0 + class_< interval_transactions > + ("IntervalTransactions", init *>()) + .def("flush", &item_handler::flush) + .def("__call__", &interval_transactions::operator()); + ; +#endif + + class_< dow_transactions > + ("DowTransactions", init *>()) + .def("flush", &dow_transactions::flush) + .def("__call__", &dow_transactions::operator()); + ; + + class_< related_transactions > + ("RelatedTransactions", init *, optional >()) + .def("flush", &item_handler::flush) + .def("__call__", &related_transactions::operator()); + ; +} + +#endif // USE_BOOST_PYTHON -- cgit v1.2.3