std::vector<flexible_type> pylambda_evaluator::bulk_eval_dict_rows(
size_t lambda_hash,
const std::vector<std::string>& keys,
const sframe_rows& rows,
bool skip_undefined,
int seed) {
python_thread_guard py_thread_guard;
set_lambda(lambda_hash);
py_set_random_seed(seed);
std::vector<flexible_type> ret(rows.num_rows());
python::dict input;
size_t cnt = 0;
try {
std::vector<flexible_type> row(rows.num_columns());
for (const auto& row_iter: rows) {
for (size_t j = 0; j < row.size(); ++j)
row[j] = row_iter[j];
PyDict_UpdateFromFlex(input, keys, row);
python::object output = m_current_lambda->operator()(input);
PyObject_AsFlex(output, ret[cnt]);
cnt++;
}
} catch (python::error_already_set const& e) {
std::string error_string = parse_python_error();
throw(error_string);
} catch (std::exception& e) {
throw(std::string(e.what()));
} catch (...) {
throw("Unknown exception from python lambda evaluation.");
}
return ret;
}
virtual size_t read_rows(size_t row_start,
size_t row_end,
sframe_rows& out_obj) {
size_t ret = 0;
out_obj.resize(1);
ret = read_rows(row_start, row_end, *(out_obj.get_columns()[0]));
return ret;
}
/// Return the next element in the chunk.
inline const sframe_rows::row& sframe_reader_buffer::next() {
if (m_buffer_pos == m_buffer.num_rows()) {
refill();
m_buffer_pos = 0;
}
DASSERT_LT(m_buffer_pos, m_buffer.num_rows());
++m_iter;
m_current.copy_reference(m_buffer[m_buffer_pos++]);
return m_current;
}
size_t sframe_reader::read_rows(size_t row_start,
size_t row_end,
sframe_rows& out_obj) {
// sframe_rows is made up of a collection of columns
out_obj.resize(column_data.size());
for (size_t i = 0;i < column_data.size(); ++i) {
column_data[i]->read_rows(row_start, row_end, *(out_obj.get_columns()[i]));
}
return out_obj.num_rows();
}
std::vector<flexible_type> pylambda_evaluator::bulk_eval_rows(
size_t lambda_hash,
const sframe_rows& rows,
bool skip_undefined,
int seed) {
python_thread_guard py_thread_guard;
set_lambda(lambda_hash);
py_set_random_seed(seed);
std::vector<flexible_type> ret(rows.num_rows());
size_t i = 0;
for (const auto& x : rows) {
if (skip_undefined && x[0] == FLEX_UNDEFINED) {
ret[i++] = FLEX_UNDEFINED;
} else {
ret[i++] = eval(lambda_hash, x[0]);
}
}
return ret;
}
inline void sframe_reader_buffer::clear() {
m_buffer.clear();
m_row_start = m_original_row_start;
m_iter = m_original_row_start;
m_buffer_pos = 0;
}
