diff options
Diffstat (limited to 'gnuradio-runtime/python')
119 files changed, 10572 insertions, 321 deletions
diff --git a/gnuradio-runtime/python/gnuradio/__init__.py b/gnuradio-runtime/python/gnuradio/__init__.py index 7e7b6d8bc4..28a493fa6b 100644 --- a/gnuradio-runtime/python/gnuradio/__init__.py +++ b/gnuradio-runtime/python/gnuradio/__init__.py @@ -42,6 +42,6 @@ if path.endswith(path_ending): __path__.append(os.path.join(build_path, 'gr-vocoder', 'python')) __path__.append(os.path.join(build_path, 'gr-channels', 'python')) __path__.append(os.path.join(build_path, 'gr-fec', 'python')) - __path__.append(os.path.join(build_path, 'gr-utils', 'python')) + __path__.append(os.path.join(build_path, 'gr-utils')) __path__.append(os.path.join(build_path, 'gr-uhd', 'python')) __path__.append(os.path.join(build_path, 'gr-zeromq', 'python')) diff --git a/gnuradio-runtime/python/gnuradio/gr/CMakeLists.txt b/gnuradio-runtime/python/gnuradio/gr/CMakeLists.txt index 459c8bc022..4633445f17 100644 --- a/gnuradio-runtime/python/gnuradio/gr/CMakeLists.txt +++ b/gnuradio-runtime/python/gnuradio/gr/CMakeLists.txt @@ -29,11 +29,6 @@ if(ENABLE_TESTING) set(GR_TEST_PYTHON_DIRS ${CMAKE_BINARY_DIR}/gruel/src/python ${CMAKE_BINARY_DIR}/gnuradio-runtime/python - ${CMAKE_BINARY_DIR}/gnuradio-runtime/swig - ${CMAKE_BINARY_DIR}/gr-blocks/swig - ${CMAKE_BINARY_DIR}/gr-fft/swig - ${CMAKE_BINARY_DIR}/gr-filter/swig - ${CMAKE_BINARY_DIR}/gr-analog/swig ) include(GrTest) file(GLOB py_qa_test_files "qa_*.py") @@ -42,3 +37,5 @@ if(ENABLE_TESTING) GR_ADD_TEST(${py_qa_test_name} ${QA_PYTHON_EXECUTABLE} -B ${py_qa_test_file}) endforeach(py_qa_test_file) endif(ENABLE_TESTING) + +add_subdirectory(bindings) diff --git a/gnuradio-runtime/python/gnuradio/gr/__init__.py b/gnuradio-runtime/python/gnuradio/gr/__init__.py index a1c1d3f397..2217907222 100644 --- a/gnuradio-runtime/python/gnuradio/gr/__init__.py +++ b/gnuradio-runtime/python/gnuradio/gr/__init__.py @@ -16,19 +16,19 @@ from __future__ import absolute_import from __future__ import unicode_literals # This is the main GNU Radio python module. -# We pull the swig output and the other modules into the gnuradio.gr namespace +# We pull the pybind output and the other modules into the gnuradio.gr namespace -# If gnuradio is installed then the swig output will be in this directory. -# Otherwise it will reside in ../../../swig. +# If gnuradio is installed then the pybind output will be in this directory. +# Otherwise it will reside in bindings/. import os, sys try: - from .runtime_swig import * + from .gr_python import * except ImportError: dirname, filename = os.path.split(os.path.abspath(__file__)) - __path__.append(os.path.join(dirname, "..", "..", "..", "swig")) - from .runtime_swig import * + __path__.append(os.path.join(dirname, "bindings")) + from .gr_python import * from .exceptions import * from .top_block import * @@ -36,8 +36,8 @@ from .hier_block2 import * from .tag_utils import * from .gateway import basic_block, sync_block, decim_block, interp_block, py_io_signature -# Force the preference database to be initialized -prefs = prefs.singleton +# # Force the preference database to be initialized +# prefs = prefs.singleton log = gr.logger("log") log.set_level(prefs().get_string("LOG", "log_level", "notset")) diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/CMakeLists.txt b/gnuradio-runtime/python/gnuradio/gr/bindings/CMakeLists.txt new file mode 100644 index 0000000000..a5704a0d90 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/CMakeLists.txt @@ -0,0 +1,90 @@ +include(GrPybind) + +######################################################################## +# Python Bindings +######################################################################## + +list(APPEND gr_python_files +messages/msg_accepter_msgq_python.cc +messages/msg_accepter_python.cc +messages/msg_passing_python.cc +messages/msg_producer_python.cc +messages/msg_queue_python.cc + # attributes_python.cc + basic_block_python.cc + block_python.cc + block_detail_python.cc + block_gateway_python.cc + # block_registry_python.cc + buffer_python.cc + constants_python.cc + endianness_python.cc + expj_python.cc + flowgraph_python.cc + fxpt_python.cc + fxpt_nco_python.cc + fxpt_vco_python.cc + # gr_complex_python.cc + hier_block2_python.cc + high_res_timer_python.cc + io_signature_python.cc + logger_python.cc + math_python.cc + + message_python.cc + msg_accepter_python.cc + # msg_accepter_msgq_python.cc + # msg_passing_python.cc + # msg_producer_python.cc + msg_queue_python.cc + # misc_python.cc + msg_accepter_python.cc + msg_handler_python.cc + msg_queue_python.cc + nco_python.cc + prefs_python.cc + # pycallback_object_python.cc + random_python.cc + realtime_python.cc + # realtime_impl_python.cc + # rpcbufferedget_python.cc + # rpccallbackregister_base_python.cc + # rpcmanager_python.cc + # rpcmanager_base_python.cc + # rpcpmtconverters_thrift_python.cc + # rpcregisterhelpers_python.cc + # rpcserver_aggregator_python.cc + # rpcserver_base_python.cc + # rpcserver_booter_aggregator_python.cc + # rpcserver_booter_base_python.cc + # rpcserver_booter_thrift_python.cc + # rpcserver_selector_python.cc + # rpcserver_thrift_python.cc + runtime_types_python.cc + sincos_python.cc + sptr_magic_python.cc + sync_block_python.cc + sync_decimator_python.cc + sync_interpolator_python.cc + sys_paths_python.cc + tag_checker_python.cc + tagged_stream_block_python.cc + tags_python.cc + # thread_python.cc + # thread_body_wrapper_python.cc + # thread_group_python.cc + # thrift_application_base_python.cc + # thrift_server_template_python.cc + top_block_python.cc + tpb_detail_python.cc + # types_python.cc + # unittests_python.cc + # xoroshiro128p_python.cc + python_bindings.cc) + +GR_PYBIND_MAKE_CHECK_HASH(gr + ../../../.. + gr::gr + "${gr_python_files}") + +install(TARGETS gr_python DESTINATION ${GR_PYTHON_DIR}/gnuradio/gr COMPONENT pythonapi) diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/basic_block_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/basic_block_python.cc new file mode 100644 index 0000000000..f66019d0c2 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/basic_block_python.cc @@ -0,0 +1,283 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(basic_block.h) */ +/* BINDTOOL_HEADER_FILE_HASH(549c06530e2afdf6f2c989017cb5f36e) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/basic_block.h> +// pydoc.h is automatically generated in the build directory +#include <basic_block_pydoc.h> + +void bind_basic_block(py::module& m) +{ + + using basic_block = ::gr::basic_block; + + + py::class_<basic_block, gr::msg_accepter, std::shared_ptr<basic_block>>( + m, "basic_block", D(basic_block)) + + + .def("message_subscribers", + &basic_block::message_subscribers, + py::arg("port"), + D(basic_block, message_subscribers)) + + + .def("unique_id", &basic_block::unique_id, D(basic_block, unique_id)) + + + .def("symbolic_id", &basic_block::symbolic_id, D(basic_block, symbolic_id)) + + + .def("name", &basic_block::name, D(basic_block, name)) + + + .def("symbol_name", &basic_block::symbol_name, D(basic_block, symbol_name)) + + + .def("identifier", &basic_block::identifier, D(basic_block, identifier)) + + + .def("input_signature", + &basic_block::input_signature, + D(basic_block, input_signature)) + + + .def("output_signature", + &basic_block::output_signature, + D(basic_block, output_signature)) + + + .def("to_basic_block", + &basic_block::to_basic_block, + D(basic_block, to_basic_block)) + + + .def("alias_set", &basic_block::alias_set, D(basic_block, alias_set)) + + + .def("alias", &basic_block::alias, D(basic_block, alias)) + + + .def("alias_pmt", &basic_block::alias_pmt, D(basic_block, alias_pmt)) + + + .def("set_block_alias", + &basic_block::set_block_alias, + py::arg("name"), + D(basic_block, set_block_alias)) + + + .def("message_port_register_in", + &basic_block::message_port_register_in, + py::arg("port_id"), + D(basic_block, message_port_register_in)) + + + .def("message_port_register_out", + &basic_block::message_port_register_out, + py::arg("port_id"), + D(basic_block, message_port_register_out)) + + + .def("message_port_pub", + &basic_block::message_port_pub, + py::arg("port_id"), + py::arg("msg"), + D(basic_block, message_port_pub)) + + + .def("message_port_sub", + &basic_block::message_port_sub, + py::arg("port_id"), + py::arg("target"), + D(basic_block, message_port_sub)) + + + .def("message_port_unsub", + &basic_block::message_port_unsub, + py::arg("port_id"), + py::arg("target"), + D(basic_block, message_port_unsub)) + + + .def("message_port_is_hier", + &basic_block::message_port_is_hier, + py::arg("port_id"), + D(basic_block, message_port_is_hier)) + + + .def("message_port_is_hier_in", + &basic_block::message_port_is_hier_in, + py::arg("port_id"), + D(basic_block, message_port_is_hier_in)) + + + .def("message_port_is_hier_out", + &basic_block::message_port_is_hier_out, + py::arg("port_id"), + D(basic_block, message_port_is_hier_out)) + + + .def("message_ports_in", + &basic_block::message_ports_in, + D(basic_block, message_ports_in)) + + + .def("message_ports_out", + &basic_block::message_ports_out, + D(basic_block, message_ports_out)) + + + .def("_post", + &basic_block::_post, + py::arg("which_port"), + py::arg("msg"), + D(basic_block, _post)) + + + .def("empty_p", + (bool (basic_block::*)(pmt::pmt_t)) & basic_block::empty_p, + py::arg("which_port"), + D(basic_block, empty_p, 0)) + + + .def("empty_p", + (bool (basic_block::*)()) & basic_block::empty_p, + D(basic_block, empty_p, 1)) + + + .def("empty_handled_p", + (bool (basic_block::*)(pmt::pmt_t)) & basic_block::empty_handled_p, + py::arg("which_port"), + D(basic_block, empty_handled_p, 0)) + + + .def("empty_handled_p", + (bool (basic_block::*)()) & basic_block::empty_handled_p, + D(basic_block, empty_handled_p, 1)) + + + .def("nmsgs", &basic_block::nmsgs, py::arg("which_port"), D(basic_block, nmsgs)) + + + .def("insert_tail", + &basic_block::insert_tail, + py::arg("which_port"), + py::arg("msg"), + D(basic_block, insert_tail)) + + + .def("delete_head_nowait", + &basic_block::delete_head_nowait, + py::arg("which_port"), + D(basic_block, delete_head_nowait)) + + + .def("get_iterator", + &basic_block::get_iterator, + py::arg("which_port"), + D(basic_block, get_iterator)) + + + .def("erase_msg", + &basic_block::erase_msg, + py::arg("which_port"), + py::arg("it"), + D(basic_block, erase_msg)) + + + .def("has_msg_port", + &basic_block::has_msg_port, + py::arg("which_port"), + D(basic_block, has_msg_port)) + + + .def("get_msg_map", &basic_block::get_msg_map, D(basic_block, get_msg_map)) + + + // .def("add_rpc_variable",&basic_block::add_rpc_variable, + // py::arg("s"), + // D(basic_block,add_rpc_variable) + // ) + + + // .def("setup_rpc",&basic_block::setup_rpc, + // D(basic_block,setup_rpc) + // ) + + + // .def("is_rpc_set",&basic_block::is_rpc_set, + // D(basic_block,is_rpc_set) + // ) + + + // .def("rpc_set",&basic_block::rpc_set, + // D(basic_block,rpc_set) + // ) + + + .def("check_topology", + &basic_block::check_topology, + py::arg("ninputs"), + py::arg("noutputs"), + D(basic_block, check_topology)) + + + .def("set_processor_affinity", + &basic_block::set_processor_affinity, + py::arg("mask"), + D(basic_block, set_processor_affinity)) + + + .def("unset_processor_affinity", + &basic_block::unset_processor_affinity, + D(basic_block, unset_processor_affinity)) + + + .def("processor_affinity", + &basic_block::processor_affinity, + D(basic_block, processor_affinity)) + + + .def("set_log_level", + &basic_block::set_log_level, + py::arg("level"), + D(basic_block, set_log_level)) + + + .def("log_level", &basic_block::log_level, D(basic_block, log_level)) + + ; + + + m.def("basic_block_ncurrently_allocated", + &::gr::basic_block_ncurrently_allocated, + D(basic_block_ncurrently_allocated)); + + + py::module m_messages = m.def_submodule("messages"); + + + py::module m_thread = m.def_submodule("thread"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/block_detail_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/block_detail_python.cc new file mode 100644 index 0000000000..219c95b153 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/block_detail_python.cc @@ -0,0 +1,358 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(block_detail.h) */ +/* BINDTOOL_HEADER_FILE_HASH(274b4f673ac76cedd3ef6d466afab2fc) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/block_detail.h> +#include <gnuradio/buffer.h> +// pydoc.h is automatically generated in the build directory +#include <block_detail_pydoc.h> + +void bind_block_detail(py::module& m) +{ + + using block_detail = ::gr::block_detail; + + + py::class_<block_detail, std::shared_ptr<block_detail>>( + m, "block_detail", D(block_detail)) + + + .def("ninputs", &block_detail::ninputs, D(block_detail, ninputs)) + + + .def("noutputs", &block_detail::noutputs, D(block_detail, noutputs)) + + + .def("sink_p", &block_detail::sink_p, D(block_detail, sink_p)) + + + .def("source_p", &block_detail::source_p, D(block_detail, source_p)) + + + .def("set_done", + &block_detail::set_done, + py::arg("done"), + D(block_detail, set_done)) + + + .def("done", &block_detail::done, D(block_detail, done)) + + + .def("set_input", + &block_detail::set_input, + py::arg("which"), + py::arg("reader"), + D(block_detail, set_input)) + + + .def("input", &block_detail::input, py::arg("which"), D(block_detail, input)) + + + .def("set_output", + &block_detail::set_output, + py::arg("which"), + py::arg("buffer"), + D(block_detail, set_output)) + + + .def("output", &block_detail::output, py::arg("which"), D(block_detail, output)) + + + .def("consume", + &block_detail::consume, + py::arg("which_input"), + py::arg("how_many_items"), + D(block_detail, consume)) + + + .def("consume_each", + &block_detail::consume_each, + py::arg("how_many_items"), + D(block_detail, consume_each)) + + + .def("produce", + &block_detail::produce, + py::arg("which_output"), + py::arg("how_many_items"), + D(block_detail, produce)) + + + .def("produce_each", + &block_detail::produce_each, + py::arg("how_many_items"), + D(block_detail, produce_each)) + + + .def("nitems_read", + &block_detail::nitems_read, + py::arg("which_input"), + D(block_detail, nitems_read)) + + + .def("nitems_written", + &block_detail::nitems_written, + py::arg("which_output"), + D(block_detail, nitems_written)) + + + .def("reset_nitem_counters", + &block_detail::reset_nitem_counters, + D(block_detail, reset_nitem_counters)) + + + .def("clear_tags", &block_detail::clear_tags, D(block_detail, clear_tags)) + + + .def("add_item_tag", + &block_detail::add_item_tag, + py::arg("which_output"), + py::arg("tag"), + D(block_detail, add_item_tag)) + + + .def("remove_item_tag", + &block_detail::remove_item_tag, + py::arg("which_input"), + py::arg("tag"), + py::arg("id"), + D(block_detail, remove_item_tag)) + + + .def("get_tags_in_range", + (void (block_detail::*)(std::vector<gr::tag_t, std::allocator<gr::tag_t>>&, + unsigned int, + uint64_t, + uint64_t, + long int)) & + block_detail::get_tags_in_range, + py::arg("v"), + py::arg("which_input"), + py::arg("abs_start"), + py::arg("abs_end"), + py::arg("id"), + D(block_detail, get_tags_in_range, 0)) + + + .def("get_tags_in_range", + (void (block_detail::*)(std::vector<gr::tag_t, std::allocator<gr::tag_t>>&, + unsigned int, + uint64_t, + uint64_t, + pmt::pmt_t const&, + long int)) & + block_detail::get_tags_in_range, + py::arg("v"), + py::arg("which_input"), + py::arg("abs_start"), + py::arg("abs_end"), + py::arg("key"), + py::arg("id"), + D(block_detail, get_tags_in_range, 1)) + + + .def("set_processor_affinity", + &block_detail::set_processor_affinity, + py::arg("mask"), + D(block_detail, set_processor_affinity)) + + + .def("unset_processor_affinity", + &block_detail::unset_processor_affinity, + D(block_detail, unset_processor_affinity)) + + + .def("thread_priority", + &block_detail::thread_priority, + D(block_detail, thread_priority)) + + + .def("set_thread_priority", + &block_detail::set_thread_priority, + py::arg("priority"), + D(block_detail, set_thread_priority)) + + + .def("start_perf_counters", + &block_detail::start_perf_counters, + D(block_detail, start_perf_counters)) + + + .def("stop_perf_counters", + &block_detail::stop_perf_counters, + py::arg("noutput_items"), + py::arg("nproduced"), + D(block_detail, stop_perf_counters)) + + + .def("reset_perf_counters", + &block_detail::reset_perf_counters, + D(block_detail, reset_perf_counters)) + + + .def("pc_noutput_items", + &block_detail::pc_noutput_items, + D(block_detail, pc_noutput_items)) + + + .def("pc_nproduced", &block_detail::pc_nproduced, D(block_detail, pc_nproduced)) + + + .def("pc_input_buffers_full", + (float (block_detail::*)(size_t)) & block_detail::pc_input_buffers_full, + py::arg("which"), + D(block_detail, pc_input_buffers_full, 0)) + + + .def("pc_input_buffers_full", + (std::vector<float, std::allocator<float>>(block_detail::*)()) & + block_detail::pc_input_buffers_full, + D(block_detail, pc_input_buffers_full, 1)) + + + .def("pc_output_buffers_full", + (float (block_detail::*)(size_t)) & block_detail::pc_output_buffers_full, + py::arg("which"), + D(block_detail, pc_output_buffers_full, 0)) + + + .def("pc_output_buffers_full", + (std::vector<float, std::allocator<float>>(block_detail::*)()) & + block_detail::pc_output_buffers_full, + D(block_detail, pc_output_buffers_full, 1)) + + + .def("pc_work_time", &block_detail::pc_work_time, D(block_detail, pc_work_time)) + + + .def("pc_noutput_items_avg", + &block_detail::pc_noutput_items_avg, + D(block_detail, pc_noutput_items_avg)) + + + .def("pc_nproduced_avg", + &block_detail::pc_nproduced_avg, + D(block_detail, pc_nproduced_avg)) + + + .def("pc_input_buffers_full_avg", + (float (block_detail::*)(size_t)) & block_detail::pc_input_buffers_full_avg, + py::arg("which"), + D(block_detail, pc_input_buffers_full_avg, 0)) + + + .def("pc_input_buffers_full_avg", + (std::vector<float, std::allocator<float>>(block_detail::*)()) & + block_detail::pc_input_buffers_full_avg, + D(block_detail, pc_input_buffers_full_avg, 1)) + + + .def("pc_output_buffers_full_avg", + (float (block_detail::*)(size_t)) & block_detail::pc_output_buffers_full_avg, + py::arg("which"), + D(block_detail, pc_output_buffers_full_avg, 0)) + + + .def("pc_output_buffers_full_avg", + (std::vector<float, std::allocator<float>>(block_detail::*)()) & + block_detail::pc_output_buffers_full_avg, + D(block_detail, pc_output_buffers_full_avg, 1)) + + + .def("pc_work_time_avg", + &block_detail::pc_work_time_avg, + D(block_detail, pc_work_time_avg)) + + + .def("pc_throughput_avg", + &block_detail::pc_throughput_avg, + D(block_detail, pc_throughput_avg)) + + + .def("pc_noutput_items_var", + &block_detail::pc_noutput_items_var, + D(block_detail, pc_noutput_items_var)) + + + .def("pc_nproduced_var", + &block_detail::pc_nproduced_var, + D(block_detail, pc_nproduced_var)) + + + .def("pc_input_buffers_full_var", + (float (block_detail::*)(size_t)) & block_detail::pc_input_buffers_full_var, + py::arg("which"), + D(block_detail, pc_input_buffers_full_var, 0)) + + + .def("pc_input_buffers_full_var", + (std::vector<float, std::allocator<float>>(block_detail::*)()) & + block_detail::pc_input_buffers_full_var, + D(block_detail, pc_input_buffers_full_var, 1)) + + + .def("pc_output_buffers_full_var", + (float (block_detail::*)(size_t)) & block_detail::pc_output_buffers_full_var, + py::arg("which"), + D(block_detail, pc_output_buffers_full_var, 0)) + + + .def("pc_output_buffers_full_var", + (std::vector<float, std::allocator<float>>(block_detail::*)()) & + block_detail::pc_output_buffers_full_var, + D(block_detail, pc_output_buffers_full_var, 1)) + + + .def("pc_work_time_var", + &block_detail::pc_work_time_var, + D(block_detail, pc_work_time_var)) + + + .def("pc_work_time_total", + &block_detail::pc_work_time_total, + D(block_detail, pc_work_time_total)) + + + .def("consumed", &block_detail::consumed, D(block_detail, consumed)) + + ; + + + m.def("make_block_detail", + &::gr::make_block_detail, + py::arg("ninputs"), + py::arg("noutputs"), + D(make_block_detail)); + + + m.def("block_detail_ncurrently_allocated", + &::gr::block_detail_ncurrently_allocated, + D(block_detail_ncurrently_allocated)); + + + py::module m_thread = m.def_submodule("thread"); + + + py::module m_messages = m.def_submodule("messages"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/block_gateway_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/block_gateway_python.cc new file mode 100644 index 0000000000..5766677bbe --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/block_gateway_python.cc @@ -0,0 +1,96 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/block_gateway.h> + +void bind_block_gateway(py::module& m) +{ + using block_gateway = gr::block_gateway; + py::class_<block_gateway, gr::block, gr::basic_block, std::shared_ptr<block_gateway>>( + m, "block_gateway") + + .def(py::init(&block_gateway::make), + py::arg("p"), + py::arg("name"), + py::arg("in_sig"), + py::arg("out_sig")) + + .def("add_item_tag", + (void (block_gateway::*)(unsigned int, const gr::tag_t&)) & + block_gateway::_add_item_tag, + py::arg("which_output"), + py::arg("tag")) + + .def("add_item_tag", + (void (block_gateway::*)(unsigned int, + uint64_t, + const pmt::pmt_t&, + const pmt::pmt_t&, + const pmt::pmt_t&)) & + block_gateway::_add_item_tag, + py::arg("which_output"), + py::arg("abs_offset"), + py::arg("key"), + py::arg("value"), + py::arg("srcid") = pmt::PMT_F) + + + .def( + "get_tags_in_range", + (std::vector<gr::tag_t>(block_gateway::*)(unsigned int, uint64_t, uint64_t)) & + block_gateway::_get_tags_in_range, + py::arg("which_input"), + py::arg("abs_start"), + py::arg("abs_end")) + + .def("get_tags_in_range", + (std::vector<gr::tag_t>(block_gateway::*)( + unsigned int, uint64_t, uint64_t, const pmt::pmt_t&)) & + block_gateway::_get_tags_in_range, + py::arg("which_input"), + py::arg("abs_start"), + py::arg("abs_end"), + py::arg("key")) + + .def( + "get_tags_in_window", + (std::vector<gr::tag_t>(block_gateway::*)(unsigned int, uint64_t, uint64_t)) & + block_gateway::_get_tags_in_range, + py::arg("which_input"), + py::arg("rel_start"), + py::arg("rel_end")) + + .def("get_tags_in_window", + (std::vector<gr::tag_t>(block_gateway::*)( + unsigned int, uint64_t, uint64_t, const pmt::pmt_t&)) & + block_gateway::_get_tags_in_range, + py::arg("which_input"), + py::arg("rel_start"), + py::arg("rel_end"), + py::arg("key")) + + .def("set_msg_handler_pybind", + &block_gateway::set_msg_handler_pybind, + py::arg("which_port"), + py::arg("handler_name")) + + ; + py::enum_<gr::gw_block_t>(m, "gw_block_t") + .value("GW_BLOCK_GENERAL", gr::GW_BLOCK_GENERAL) + .value("GW_BLOCK_SYNC", gr::GW_BLOCK_SYNC) + .value("GW_BLOCK_DECIM", gr::GW_BLOCK_DECIM) + .value("GW_BLOCK_INTERP", gr::GW_BLOCK_INTERP) + .export_values(); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/block_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/block_python.cc new file mode 100644 index 0000000000..56a172364f --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/block_python.cc @@ -0,0 +1,501 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(block.h) */ +/* BINDTOOL_HEADER_FILE_HASH(3e181f6028976ba3727d29f45ebaa6cf) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/block.h> +// pydoc.h is automatically generated in the build directory +#include <gnuradio/block_detail.h> +#include <block_pydoc.h> + +void bind_block(py::module& m) +{ + + using block = ::gr::block; + + + py::class_<block, gr::basic_block, std::shared_ptr<block>>(m, "block", D(block)) + + + .def("history", &block::history, D(block, history)) + + + .def( + "set_history", &block::set_history, py::arg("history"), D(block, set_history)) + + + .def("declare_sample_delay", + (void (block::*)(int, unsigned int)) & block::declare_sample_delay, + py::arg("which"), + py::arg("delay"), + D(block, declare_sample_delay, 0)) + + + .def("declare_sample_delay", + (void (block::*)(unsigned int)) & block::declare_sample_delay, + py::arg("delay"), + D(block, declare_sample_delay, 1)) + + + .def("sample_delay", + &block::sample_delay, + py::arg("which"), + D(block, sample_delay)) + + + .def("fixed_rate", &block::fixed_rate, D(block, fixed_rate)) + + + .def("forecast", + &block::forecast, + py::arg("noutput_items"), + py::arg("ninput_items_required"), + D(block, forecast)) + + + .def("general_work", + &block::general_work, + py::arg("noutput_items"), + py::arg("ninput_items"), + py::arg("input_items"), + py::arg("output_items"), + D(block, general_work)) + + + .def("start", &block::start, D(block, start)) + + + .def("stop", &block::stop, D(block, stop)) + + + .def("set_output_multiple", + &block::set_output_multiple, + py::arg("multiple"), + D(block, set_output_multiple)) + + + .def("output_multiple", &block::output_multiple, D(block, output_multiple)) + + + .def("output_multiple_set", + &block::output_multiple_set, + D(block, output_multiple_set)) + + + .def("set_alignment", + &block::set_alignment, + py::arg("multiple"), + D(block, set_alignment)) + + + .def("alignment", &block::alignment, D(block, alignment)) + + + .def("set_unaligned", + &block::set_unaligned, + py::arg("na"), + D(block, set_unaligned)) + + + .def("unaligned", &block::unaligned, D(block, unaligned)) + + + .def("set_is_unaligned", + &block::set_is_unaligned, + py::arg("u"), + D(block, set_is_unaligned)) + + + .def("is_unaligned", &block::is_unaligned, D(block, is_unaligned)) + + + .def("consume", + &block::consume, + py::arg("which_input"), + py::arg("how_many_items"), + D(block, consume)) + + + .def("consume_each", + &block::consume_each, + py::arg("how_many_items"), + D(block, consume_each)) + + + .def("produce", + &block::produce, + py::arg("which_output"), + py::arg("how_many_items"), + D(block, produce)) + + + .def("set_relative_rate", + (void (block::*)(double)) & block::set_relative_rate, + py::arg("relative_rate"), + D(block, set_relative_rate, 0)) + + + .def("set_inverse_relative_rate", + &block::set_inverse_relative_rate, + py::arg("inverse_relative_rate"), + D(block, set_inverse_relative_rate)) + + + .def("set_relative_rate", + (void (block::*)(uint64_t, uint64_t)) & block::set_relative_rate, + py::arg("interpolation"), + py::arg("decimation"), + D(block, set_relative_rate, 1)) + + + .def("relative_rate", &block::relative_rate, D(block, relative_rate)) + + + .def("relative_rate_i", &block::relative_rate_i, D(block, relative_rate_i)) + + + .def("relative_rate_d", &block::relative_rate_d, D(block, relative_rate_d)) + + + .def("mp_relative_rate", &block::mp_relative_rate, D(block, mp_relative_rate)) + + + .def("fixed_rate_ninput_to_noutput", + &block::fixed_rate_ninput_to_noutput, + py::arg("ninput"), + D(block, fixed_rate_ninput_to_noutput)) + + + .def("fixed_rate_noutput_to_ninput", + &block::fixed_rate_noutput_to_ninput, + py::arg("noutput"), + D(block, fixed_rate_noutput_to_ninput)) + + + .def("nitems_read", + &block::nitems_read, + py::arg("which_input"), + D(block, nitems_read)) + + + .def("nitems_written", + &block::nitems_written, + py::arg("which_output"), + D(block, nitems_written)) + + + .def("tag_propagation_policy", + &block::tag_propagation_policy, + D(block, tag_propagation_policy)) + + + .def("set_tag_propagation_policy", + &block::set_tag_propagation_policy, + py::arg("p"), + D(block, set_tag_propagation_policy)) + + + .def("min_noutput_items", &block::min_noutput_items, D(block, min_noutput_items)) + + + .def("set_min_noutput_items", + &block::set_min_noutput_items, + py::arg("m"), + D(block, set_min_noutput_items)) + + + .def("max_noutput_items", &block::max_noutput_items, D(block, max_noutput_items)) + + + .def("set_max_noutput_items", + &block::set_max_noutput_items, + py::arg("m"), + D(block, set_max_noutput_items)) + + + .def("unset_max_noutput_items", + &block::unset_max_noutput_items, + D(block, unset_max_noutput_items)) + + + .def("is_set_max_noutput_items", + &block::is_set_max_noutput_items, + D(block, is_set_max_noutput_items)) + + + .def("expand_minmax_buffer", + &block::expand_minmax_buffer, + py::arg("port"), + D(block, expand_minmax_buffer)) + + + .def("max_output_buffer", + &block::max_output_buffer, + py::arg("i"), + D(block, max_output_buffer)) + + + .def("set_max_output_buffer", + (void (block::*)(long int)) & block::set_max_output_buffer, + py::arg("max_output_buffer"), + D(block, set_max_output_buffer, 0)) + + + .def("set_max_output_buffer", + (void (block::*)(int, long int)) & block::set_max_output_buffer, + py::arg("port"), + py::arg("max_output_buffer"), + D(block, set_max_output_buffer, 1)) + + + .def("min_output_buffer", + &block::min_output_buffer, + py::arg("i"), + D(block, min_output_buffer)) + + + .def("set_min_output_buffer", + (void (block::*)(long int)) & block::set_min_output_buffer, + py::arg("min_output_buffer"), + D(block, set_min_output_buffer, 0)) + + + .def("set_min_output_buffer", + (void (block::*)(int, long int)) & block::set_min_output_buffer, + py::arg("port"), + py::arg("min_output_buffer"), + D(block, set_min_output_buffer, 1)) + + + .def("pc_noutput_items", &block::pc_noutput_items, D(block, pc_noutput_items)) + + + .def("pc_noutput_items_avg", + &block::pc_noutput_items_avg, + D(block, pc_noutput_items_avg)) + + + .def("pc_noutput_items_var", + &block::pc_noutput_items_var, + D(block, pc_noutput_items_var)) + + + .def("pc_nproduced", &block::pc_nproduced, D(block, pc_nproduced)) + + + .def("pc_nproduced_avg", &block::pc_nproduced_avg, D(block, pc_nproduced_avg)) + + + .def("pc_nproduced_var", &block::pc_nproduced_var, D(block, pc_nproduced_var)) + + + .def("pc_input_buffers_full", + (float (block::*)(int)) & block::pc_input_buffers_full, + py::arg("which"), + D(block, pc_input_buffers_full, 0)) + + + .def("pc_input_buffers_full_avg", + (float (block::*)(int)) & block::pc_input_buffers_full_avg, + py::arg("which"), + D(block, pc_input_buffers_full_avg, 0)) + + + .def("pc_input_buffers_full_var", + (float (block::*)(int)) & block::pc_input_buffers_full_var, + py::arg("which"), + D(block, pc_input_buffers_full_var, 0)) + + + .def("pc_input_buffers_full", + (std::vector<float, std::allocator<float>>(block::*)()) & + block::pc_input_buffers_full, + D(block, pc_input_buffers_full, 1)) + + + .def("pc_input_buffers_full_avg", + (std::vector<float, std::allocator<float>>(block::*)()) & + block::pc_input_buffers_full_avg, + D(block, pc_input_buffers_full_avg, 1)) + + + .def("pc_input_buffers_full_var", + (std::vector<float, std::allocator<float>>(block::*)()) & + block::pc_input_buffers_full_var, + D(block, pc_input_buffers_full_var, 1)) + + + .def("pc_output_buffers_full", + (float (block::*)(int)) & block::pc_output_buffers_full, + py::arg("which"), + D(block, pc_output_buffers_full, 0)) + + + .def("pc_output_buffers_full_avg", + (float (block::*)(int)) & block::pc_output_buffers_full_avg, + py::arg("which"), + D(block, pc_output_buffers_full_avg, 0)) + + + .def("pc_output_buffers_full_var", + (float (block::*)(int)) & block::pc_output_buffers_full_var, + py::arg("which"), + D(block, pc_output_buffers_full_var, 0)) + + + .def("pc_output_buffers_full", + (std::vector<float, std::allocator<float>>(block::*)()) & + block::pc_output_buffers_full, + D(block, pc_output_buffers_full, 1)) + + + .def("pc_output_buffers_full_avg", + (std::vector<float, std::allocator<float>>(block::*)()) & + block::pc_output_buffers_full_avg, + D(block, pc_output_buffers_full_avg, 1)) + + + .def("pc_output_buffers_full_var", + (std::vector<float, std::allocator<float>>(block::*)()) & + block::pc_output_buffers_full_var, + D(block, pc_output_buffers_full_var, 1)) + + + .def("pc_work_time", &block::pc_work_time, D(block, pc_work_time)) + + + .def("pc_work_time_avg", &block::pc_work_time_avg, D(block, pc_work_time_avg)) + + + .def("pc_work_time_var", &block::pc_work_time_var, D(block, pc_work_time_var)) + + + .def("pc_work_time_total", + &block::pc_work_time_total, + D(block, pc_work_time_total)) + + + .def("pc_throughput_avg", &block::pc_throughput_avg, D(block, pc_throughput_avg)) + + + .def("reset_perf_counters", + &block::reset_perf_counters, + D(block, reset_perf_counters)) + + + .def("setup_pc_rpc", &block::setup_pc_rpc, D(block, setup_pc_rpc)) + + + .def("is_pc_rpc_set", &block::is_pc_rpc_set, D(block, is_pc_rpc_set)) + + + .def("no_pc_rpc", &block::no_pc_rpc, D(block, no_pc_rpc)) + + + .def("set_processor_affinity", + &block::set_processor_affinity, + py::arg("mask"), + D(block, set_processor_affinity)) + + + .def("unset_processor_affinity", + &block::unset_processor_affinity, + D(block, unset_processor_affinity)) + + + .def("processor_affinity", + &block::processor_affinity, + D(block, processor_affinity)) + + + .def("active_thread_priority", + &block::active_thread_priority, + D(block, active_thread_priority)) + + + .def("thread_priority", &block::thread_priority, D(block, thread_priority)) + + + .def("set_thread_priority", + &block::set_thread_priority, + py::arg("priority"), + D(block, set_thread_priority)) + + + .def("update_rate", &block::update_rate, D(block, update_rate)) + + + .def("system_handler", + &block::system_handler, + py::arg("msg"), + D(block, system_handler)) + + + .def("set_log_level", + &block::set_log_level, + py::arg("level"), + D(block, set_log_level)) + + + .def("log_level", &block::log_level, D(block, log_level)) + + + .def("finished", &block::finished, D(block, finished)) + + + .def("detail", &block::detail, D(block, detail)) + + + .def("set_detail", &block::set_detail, py::arg("detail"), D(block, set_detail)) + + + .def("notify_msg_neighbors", + &block::notify_msg_neighbors, + D(block, notify_msg_neighbors)) + + + .def("clear_finished", &block::clear_finished, D(block, clear_finished)) + + + .def("identifier", &block::identifier, D(block, identifier)) + + ; + + + m.def("cast_to_block_sptr", + &::gr::cast_to_block_sptr, + py::arg("p"), + D(cast_to_block_sptr)); + + + py::enum_<gr::block::work_return_t>(m, "work_return_t") + .value("WORK_CALLED_PRODUCE", gr::block::WORK_CALLED_PRODUCE) // -2 + .value("WORK_DONE", gr::block::WORK_DONE) // -1 + .export_values(); + py::enum_<gr::block::tag_propagation_policy_t>(m, "tag_propagation_policy_t") + .value("TPP_DONT", gr::block::TPP_DONT) // 0 + .value("TPP_ALL_TO_ALL", gr::block::TPP_ALL_TO_ALL) // 1 + .value("TPP_ONE_TO_ONE", gr::block::TPP_ONE_TO_ONE) // 2 + .value("TPP_CUSTOM", gr::block::TPP_CUSTOM) // 3 + .export_values(); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/buffer_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/buffer_python.cc new file mode 100644 index 0000000000..ef51929d6c --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/buffer_python.cc @@ -0,0 +1,234 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(buffer.h) */ +/* BINDTOOL_HEADER_FILE_HASH(825bd18ddcab10552de6f9162a6aae3e) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/block.h> +#include <gnuradio/buffer.h> +// pydoc.h is automatically generated in the build directory +#include <buffer_pydoc.h> + +void bind_buffer(py::module& m) +{ + + using buffer = ::gr::buffer; + using buffer_reader = ::gr::buffer_reader; + + + py::class_<buffer, std::shared_ptr<buffer>>(m, "buffer", D(buffer)) + + + .def("space_available", &buffer::space_available, D(buffer, space_available)) + + + .def("bufsize", &buffer::bufsize, D(buffer, bufsize)) + + + .def("base", &buffer::base, D(buffer, base)) + + + .def("write_pointer", &buffer::write_pointer, D(buffer, write_pointer)) + + + .def("update_write_pointer", + &buffer::update_write_pointer, + py::arg("nitems"), + D(buffer, update_write_pointer)) + + + .def("set_done", &buffer::set_done, py::arg("done"), D(buffer, set_done)) + + + .def("done", &buffer::done, D(buffer, done)) + + + .def("link", &buffer::link, D(buffer, link)) + + + .def("nreaders", &buffer::nreaders, D(buffer, nreaders)) + + + .def("reader", &buffer::reader, py::arg("index"), D(buffer, reader)) + + + .def("mutex", &buffer::mutex, D(buffer, mutex)) + + + .def("nitems_written", &buffer::nitems_written, D(buffer, nitems_written)) + + + .def("reset_nitem_counter", + &buffer::reset_nitem_counter, + D(buffer, reset_nitem_counter)) + + + .def("get_sizeof_item", &buffer::get_sizeof_item, D(buffer, get_sizeof_item)) + + + .def("add_item_tag", + &buffer::add_item_tag, + py::arg("tag"), + D(buffer, add_item_tag)) + + + .def("remove_item_tag", + &buffer::remove_item_tag, + py::arg("tag"), + py::arg("id"), + D(buffer, remove_item_tag)) + + + .def( + "prune_tags", &buffer::prune_tags, py::arg("max_time"), D(buffer, prune_tags)) + + + .def("get_tags_begin", &buffer::get_tags_begin, D(buffer, get_tags_begin)) + + + .def("get_tags_end", &buffer::get_tags_end, D(buffer, get_tags_end)) + + + .def("get_tags_lower_bound", + &buffer::get_tags_lower_bound, + py::arg("x"), + D(buffer, get_tags_lower_bound)) + + + .def("get_tags_upper_bound", + &buffer::get_tags_upper_bound, + py::arg("x"), + D(buffer, get_tags_upper_bound)) + + ; + + + py::class_<buffer_reader, std::shared_ptr<buffer_reader>>( + m, "buffer_reader", D(buffer_reader)) + + .def(py::init<gr::buffer_reader const&>(), + py::arg("arg0"), + D(buffer_reader, buffer_reader)) + + + .def("declare_sample_delay", + &buffer_reader::declare_sample_delay, + py::arg("delay"), + D(buffer_reader, declare_sample_delay)) + + + .def("sample_delay", &buffer_reader::sample_delay, D(buffer_reader, sample_delay)) + + + .def("items_available", + &buffer_reader::items_available, + D(buffer_reader, items_available)) + + + .def("buffer", &buffer_reader::buffer, D(buffer_reader, buffer)) + + + .def("max_possible_items_available", + &buffer_reader::max_possible_items_available, + D(buffer_reader, max_possible_items_available)) + + + .def("read_pointer", &buffer_reader::read_pointer, D(buffer_reader, read_pointer)) + + + .def("update_read_pointer", + &buffer_reader::update_read_pointer, + py::arg("nitems"), + D(buffer_reader, update_read_pointer)) + + + .def("set_done", + &buffer_reader::set_done, + py::arg("done"), + D(buffer_reader, set_done)) + + + .def("done", &buffer_reader::done, D(buffer_reader, done)) + + + .def("mutex", &buffer_reader::mutex, D(buffer_reader, mutex)) + + + .def("nitems_read", &buffer_reader::nitems_read, D(buffer_reader, nitems_read)) + + + .def("reset_nitem_counter", + &buffer_reader::reset_nitem_counter, + D(buffer_reader, reset_nitem_counter)) + + + .def("get_sizeof_item", + &buffer_reader::get_sizeof_item, + D(buffer_reader, get_sizeof_item)) + + + .def("link", &buffer_reader::link, D(buffer_reader, link)) + + + .def("get_tags_in_range", + &buffer_reader::get_tags_in_range, + py::arg("v"), + py::arg("abs_start"), + py::arg("abs_end"), + py::arg("id"), + D(buffer_reader, get_tags_in_range)) + + ; + + + m.def("make_buffer", + &::gr::make_buffer, + py::arg("nitems"), + py::arg("sizeof_item"), + py::arg("link") = gr::block_sptr(), + D(make_buffer)); + + + m.def("buffer_add_reader", + &::gr::buffer_add_reader, + py::arg("buf"), + py::arg("nzero_preload"), + py::arg("link") = gr::block_sptr(), + py::arg("delay") = 0, + D(buffer_add_reader)); + + + m.def("buffer_ncurrently_allocated", + &::gr::buffer_ncurrently_allocated, + D(buffer_ncurrently_allocated)); + + + m.def("buffer_reader_ncurrently_allocated", + &::gr::buffer_reader_ncurrently_allocated, + D(buffer_reader_ncurrently_allocated)); + + + py::module m_thread = m.def_submodule("thread"); + + + py::module m_messages = m.def_submodule("messages"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/constants_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/constants_python.cc new file mode 100644 index 0000000000..e2624e808d --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/constants_python.cc @@ -0,0 +1,70 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(constants.h) */ +/* BINDTOOL_HEADER_FILE_HASH(d98c7e72cb74921e5e07f332dbf5475a) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/constants.h> +// pydoc.h is automatically generated in the build directory +#include <constants_pydoc.h> + +void bind_constants(py::module& m) +{ + + + m.def("prefix", &::gr::prefix, D(prefix)); + + + m.def("sysconfdir", &::gr::sysconfdir, D(sysconfdir)); + + + m.def("prefsdir", &::gr::prefsdir, D(prefsdir)); + + + m.def("build_date", &::gr::build_date, D(build_date)); + + + m.def("version", &::gr::version, D(version)); + + + m.def("major_version", &::gr::major_version, D(major_version)); + + + m.def("api_version", &::gr::api_version, D(api_version)); + + + m.def("minor_version", &::gr::minor_version, D(minor_version)); + + + m.def("c_compiler", &::gr::c_compiler, D(c_compiler)); + + + m.def("cxx_compiler", &::gr::cxx_compiler, D(cxx_compiler)); + + + m.def("compiler_flags", &::gr::compiler_flags, D(compiler_flags)); + + + m.def("build_time_enabled_components", + &::gr::build_time_enabled_components, + D(build_time_enabled_components)); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/basic_block_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/basic_block_pydoc_template.h new file mode 100644 index 0000000000..f51175f1b6 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/basic_block_pydoc_template.h @@ -0,0 +1,156 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_basic_block = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_subscribers = R"doc()doc"; + + +static const char* __doc_gr_basic_block_unique_id = R"doc()doc"; + + +static const char* __doc_gr_basic_block_symbolic_id = R"doc()doc"; + + +static const char* __doc_gr_basic_block_name = R"doc()doc"; + + +static const char* __doc_gr_basic_block_symbol_name = R"doc()doc"; + + +static const char* __doc_gr_basic_block_identifier = R"doc()doc"; + + +static const char* __doc_gr_basic_block_input_signature = R"doc()doc"; + + +static const char* __doc_gr_basic_block_output_signature = R"doc()doc"; + + +static const char* __doc_gr_basic_block_to_basic_block = R"doc()doc"; + + +static const char* __doc_gr_basic_block_alias_set = R"doc()doc"; + + +static const char* __doc_gr_basic_block_alias = R"doc()doc"; + + +static const char* __doc_gr_basic_block_alias_pmt = R"doc()doc"; + + +static const char* __doc_gr_basic_block_set_block_alias = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_port_register_in = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_port_register_out = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_port_pub = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_port_sub = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_port_unsub = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_port_is_hier = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_port_is_hier_in = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_port_is_hier_out = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_ports_in = R"doc()doc"; + + +static const char* __doc_gr_basic_block_message_ports_out = R"doc()doc"; + + +static const char* __doc_gr_basic_block__post = R"doc()doc"; + + +static const char* __doc_gr_basic_block_empty_p_0 = R"doc()doc"; + + +static const char* __doc_gr_basic_block_empty_p_1 = R"doc()doc"; + + +static const char* __doc_gr_basic_block_empty_handled_p_0 = R"doc()doc"; + + +static const char* __doc_gr_basic_block_empty_handled_p_1 = R"doc()doc"; + + +static const char* __doc_gr_basic_block_nmsgs = R"doc()doc"; + + +static const char* __doc_gr_basic_block_insert_tail = R"doc()doc"; + + +static const char* __doc_gr_basic_block_delete_head_nowait = R"doc()doc"; + + +static const char* __doc_gr_basic_block_get_iterator = R"doc()doc"; + + +static const char* __doc_gr_basic_block_erase_msg = R"doc()doc"; + + +static const char* __doc_gr_basic_block_has_msg_port = R"doc()doc"; + + +static const char* __doc_gr_basic_block_get_msg_map = R"doc()doc"; + + +static const char* __doc_gr_basic_block_add_rpc_variable = R"doc()doc"; + + +static const char* __doc_gr_basic_block_setup_rpc = R"doc()doc"; + + +static const char* __doc_gr_basic_block_is_rpc_set = R"doc()doc"; + + +static const char* __doc_gr_basic_block_rpc_set = R"doc()doc"; + + +static const char* __doc_gr_basic_block_check_topology = R"doc()doc"; + + +static const char* __doc_gr_basic_block_set_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_basic_block_unset_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_basic_block_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_basic_block_set_log_level = R"doc()doc"; + + +static const char* __doc_gr_basic_block_log_level = R"doc()doc"; + + +static const char* __doc_gr_basic_block_ncurrently_allocated = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/block_detail_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/block_detail_pydoc_template.h new file mode 100644 index 0000000000..eb010d04a4 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/block_detail_pydoc_template.h @@ -0,0 +1,183 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_block_detail = R"doc()doc"; + + +static const char* __doc_gr_block_detail_ninputs = R"doc()doc"; + + +static const char* __doc_gr_block_detail_noutputs = R"doc()doc"; + + +static const char* __doc_gr_block_detail_sink_p = R"doc()doc"; + + +static const char* __doc_gr_block_detail_source_p = R"doc()doc"; + + +static const char* __doc_gr_block_detail_set_done = R"doc()doc"; + + +static const char* __doc_gr_block_detail_done = R"doc()doc"; + + +static const char* __doc_gr_block_detail_set_input = R"doc()doc"; + + +static const char* __doc_gr_block_detail_input = R"doc()doc"; + + +static const char* __doc_gr_block_detail_set_output = R"doc()doc"; + + +static const char* __doc_gr_block_detail_output = R"doc()doc"; + + +static const char* __doc_gr_block_detail_consume = R"doc()doc"; + + +static const char* __doc_gr_block_detail_consume_each = R"doc()doc"; + + +static const char* __doc_gr_block_detail_produce = R"doc()doc"; + + +static const char* __doc_gr_block_detail_produce_each = R"doc()doc"; + + +static const char* __doc_gr_block_detail_nitems_read = R"doc()doc"; + + +static const char* __doc_gr_block_detail_nitems_written = R"doc()doc"; + + +static const char* __doc_gr_block_detail_reset_nitem_counters = R"doc()doc"; + + +static const char* __doc_gr_block_detail_clear_tags = R"doc()doc"; + + +static const char* __doc_gr_block_detail_add_item_tag = R"doc()doc"; + + +static const char* __doc_gr_block_detail_remove_item_tag = R"doc()doc"; + + +static const char* __doc_gr_block_detail_get_tags_in_range_0 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_get_tags_in_range_1 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_set_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_block_detail_unset_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_block_detail_thread_priority = R"doc()doc"; + + +static const char* __doc_gr_block_detail_set_thread_priority = R"doc()doc"; + + +static const char* __doc_gr_block_detail_start_perf_counters = R"doc()doc"; + + +static const char* __doc_gr_block_detail_stop_perf_counters = R"doc()doc"; + + +static const char* __doc_gr_block_detail_reset_perf_counters = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_nproduced = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_input_buffers_full_0 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_input_buffers_full_1 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_output_buffers_full_0 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_output_buffers_full_1 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_work_time = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_noutput_items_avg = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_nproduced_avg = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_input_buffers_full_avg_0 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_input_buffers_full_avg_1 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_output_buffers_full_avg_0 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_output_buffers_full_avg_1 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_work_time_avg = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_throughput_avg = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_noutput_items_var = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_nproduced_var = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_input_buffers_full_var_0 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_input_buffers_full_var_1 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_output_buffers_full_var_0 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_output_buffers_full_var_1 = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_work_time_var = R"doc()doc"; + + +static const char* __doc_gr_block_detail_pc_work_time_total = R"doc()doc"; + + +static const char* __doc_gr_block_detail_consumed = R"doc()doc"; + + +static const char* __doc_gr_make_block_detail = R"doc()doc"; + + +static const char* __doc_gr_block_detail_ncurrently_allocated = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/block_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/block_pydoc_template.h new file mode 100644 index 0000000000..d60a699fec --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/block_pydoc_template.h @@ -0,0 +1,294 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_block = R"doc()doc"; + + +static const char* __doc_gr_block_history = R"doc()doc"; + + +static const char* __doc_gr_block_set_history = R"doc()doc"; + + +static const char* __doc_gr_block_declare_sample_delay_0 = R"doc()doc"; + + +static const char* __doc_gr_block_declare_sample_delay_1 = R"doc()doc"; + + +static const char* __doc_gr_block_sample_delay = R"doc()doc"; + + +static const char* __doc_gr_block_fixed_rate = R"doc()doc"; + + +static const char* __doc_gr_block_forecast = R"doc()doc"; + + +static const char* __doc_gr_block_general_work = R"doc()doc"; + + +static const char* __doc_gr_block_start = R"doc()doc"; + + +static const char* __doc_gr_block_stop = R"doc()doc"; + + +static const char* __doc_gr_block_set_output_multiple = R"doc()doc"; + + +static const char* __doc_gr_block_output_multiple = R"doc()doc"; + + +static const char* __doc_gr_block_output_multiple_set = R"doc()doc"; + + +static const char* __doc_gr_block_set_alignment = R"doc()doc"; + + +static const char* __doc_gr_block_alignment = R"doc()doc"; + + +static const char* __doc_gr_block_set_unaligned = R"doc()doc"; + + +static const char* __doc_gr_block_unaligned = R"doc()doc"; + + +static const char* __doc_gr_block_set_is_unaligned = R"doc()doc"; + + +static const char* __doc_gr_block_is_unaligned = R"doc()doc"; + + +static const char* __doc_gr_block_consume = R"doc()doc"; + + +static const char* __doc_gr_block_consume_each = R"doc()doc"; + + +static const char* __doc_gr_block_produce = R"doc()doc"; + + +static const char* __doc_gr_block_set_relative_rate_0 = R"doc()doc"; + + +static const char* __doc_gr_block_set_inverse_relative_rate = R"doc()doc"; + + +static const char* __doc_gr_block_set_relative_rate_1 = R"doc()doc"; + + +static const char* __doc_gr_block_relative_rate = R"doc()doc"; + + +static const char* __doc_gr_block_relative_rate_i = R"doc()doc"; + + +static const char* __doc_gr_block_relative_rate_d = R"doc()doc"; + + +static const char* __doc_gr_block_mp_relative_rate = R"doc()doc"; + + +static const char* __doc_gr_block_fixed_rate_ninput_to_noutput = R"doc()doc"; + + +static const char* __doc_gr_block_fixed_rate_noutput_to_ninput = R"doc()doc"; + + +static const char* __doc_gr_block_nitems_read = R"doc()doc"; + + +static const char* __doc_gr_block_nitems_written = R"doc()doc"; + + +static const char* __doc_gr_block_tag_propagation_policy = R"doc()doc"; + + +static const char* __doc_gr_block_set_tag_propagation_policy = R"doc()doc"; + + +static const char* __doc_gr_block_min_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_block_set_min_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_block_max_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_block_set_max_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_block_unset_max_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_block_is_set_max_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_block_expand_minmax_buffer = R"doc()doc"; + + +static const char* __doc_gr_block_max_output_buffer = R"doc()doc"; + + +static const char* __doc_gr_block_set_max_output_buffer_0 = R"doc()doc"; + + +static const char* __doc_gr_block_set_max_output_buffer_1 = R"doc()doc"; + + +static const char* __doc_gr_block_min_output_buffer = R"doc()doc"; + + +static const char* __doc_gr_block_set_min_output_buffer_0 = R"doc()doc"; + + +static const char* __doc_gr_block_set_min_output_buffer_1 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_block_pc_noutput_items_avg = R"doc()doc"; + + +static const char* __doc_gr_block_pc_noutput_items_var = R"doc()doc"; + + +static const char* __doc_gr_block_pc_nproduced = R"doc()doc"; + + +static const char* __doc_gr_block_pc_nproduced_avg = R"doc()doc"; + + +static const char* __doc_gr_block_pc_nproduced_var = R"doc()doc"; + + +static const char* __doc_gr_block_pc_input_buffers_full_0 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_input_buffers_full_avg_0 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_input_buffers_full_var_0 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_input_buffers_full_1 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_input_buffers_full_avg_1 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_input_buffers_full_var_1 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_output_buffers_full_0 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_output_buffers_full_avg_0 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_output_buffers_full_var_0 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_output_buffers_full_1 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_output_buffers_full_avg_1 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_output_buffers_full_var_1 = R"doc()doc"; + + +static const char* __doc_gr_block_pc_work_time = R"doc()doc"; + + +static const char* __doc_gr_block_pc_work_time_avg = R"doc()doc"; + + +static const char* __doc_gr_block_pc_work_time_var = R"doc()doc"; + + +static const char* __doc_gr_block_pc_work_time_total = R"doc()doc"; + + +static const char* __doc_gr_block_pc_throughput_avg = R"doc()doc"; + + +static const char* __doc_gr_block_reset_perf_counters = R"doc()doc"; + + +static const char* __doc_gr_block_setup_pc_rpc = R"doc()doc"; + + +static const char* __doc_gr_block_is_pc_rpc_set = R"doc()doc"; + + +static const char* __doc_gr_block_no_pc_rpc = R"doc()doc"; + + +static const char* __doc_gr_block_set_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_block_unset_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_block_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_block_active_thread_priority = R"doc()doc"; + + +static const char* __doc_gr_block_thread_priority = R"doc()doc"; + + +static const char* __doc_gr_block_set_thread_priority = R"doc()doc"; + + +static const char* __doc_gr_block_update_rate = R"doc()doc"; + + +static const char* __doc_gr_block_system_handler = R"doc()doc"; + + +static const char* __doc_gr_block_set_log_level = R"doc()doc"; + + +static const char* __doc_gr_block_log_level = R"doc()doc"; + + +static const char* __doc_gr_block_finished = R"doc()doc"; + + +static const char* __doc_gr_block_detail = R"doc()doc"; + + +static const char* __doc_gr_block_set_detail = R"doc()doc"; + + +static const char* __doc_gr_block_notify_msg_neighbors = R"doc()doc"; + + +static const char* __doc_gr_block_clear_finished = R"doc()doc"; + + +static const char* __doc_gr_block_identifier = R"doc()doc"; + + +static const char* __doc_gr_cast_to_block_sptr = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/buffer_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/buffer_pydoc_template.h new file mode 100644 index 0000000000..72aec93fa9 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/buffer_pydoc_template.h @@ -0,0 +1,144 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_buffer = R"doc()doc"; + + +static const char* __doc_gr_buffer_space_available = R"doc()doc"; + + +static const char* __doc_gr_buffer_bufsize = R"doc()doc"; + + +static const char* __doc_gr_buffer_base = R"doc()doc"; + + +static const char* __doc_gr_buffer_write_pointer = R"doc()doc"; + + +static const char* __doc_gr_buffer_update_write_pointer = R"doc()doc"; + + +static const char* __doc_gr_buffer_set_done = R"doc()doc"; + + +static const char* __doc_gr_buffer_done = R"doc()doc"; + + +static const char* __doc_gr_buffer_link = R"doc()doc"; + + +static const char* __doc_gr_buffer_nreaders = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader = R"doc()doc"; + + +static const char* __doc_gr_buffer_mutex = R"doc()doc"; + + +static const char* __doc_gr_buffer_nitems_written = R"doc()doc"; + + +static const char* __doc_gr_buffer_reset_nitem_counter = R"doc()doc"; + + +static const char* __doc_gr_buffer_get_sizeof_item = R"doc()doc"; + + +static const char* __doc_gr_buffer_add_item_tag = R"doc()doc"; + + +static const char* __doc_gr_buffer_remove_item_tag = R"doc()doc"; + + +static const char* __doc_gr_buffer_prune_tags = R"doc()doc"; + + +static const char* __doc_gr_buffer_get_tags_begin = R"doc()doc"; + + +static const char* __doc_gr_buffer_get_tags_end = R"doc()doc"; + + +static const char* __doc_gr_buffer_get_tags_lower_bound = R"doc()doc"; + + +static const char* __doc_gr_buffer_get_tags_upper_bound = R"doc()doc"; + + +// static const char *__doc_gr_buffer_reader = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_buffer_reader = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_declare_sample_delay = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_sample_delay = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_items_available = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_buffer = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_max_possible_items_available = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_read_pointer = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_update_read_pointer = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_set_done = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_done = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_mutex = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_nitems_read = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_reset_nitem_counter = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_get_sizeof_item = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_link = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_get_tags_in_range = R"doc()doc"; + + +static const char* __doc_gr_make_buffer = R"doc()doc"; + + +static const char* __doc_gr_buffer_add_reader = R"doc()doc"; + + +static const char* __doc_gr_buffer_ncurrently_allocated = R"doc()doc"; + + +static const char* __doc_gr_buffer_reader_ncurrently_allocated = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/constants_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/constants_pydoc_template.h new file mode 100644 index 0000000000..4ac45ae049 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/constants_pydoc_template.h @@ -0,0 +1,51 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_prefix = R"doc()doc"; + + +static const char* __doc_gr_sysconfdir = R"doc()doc"; + + +static const char* __doc_gr_prefsdir = R"doc()doc"; + + +static const char* __doc_gr_build_date = R"doc()doc"; + + +static const char* __doc_gr_version = R"doc()doc"; + + +static const char* __doc_gr_major_version = R"doc()doc"; + + +static const char* __doc_gr_api_version = R"doc()doc"; + + +static const char* __doc_gr_minor_version = R"doc()doc"; + + +static const char* __doc_gr_c_compiler = R"doc()doc"; + + +static const char* __doc_gr_cxx_compiler = R"doc()doc"; + + +static const char* __doc_gr_compiler_flags = R"doc()doc"; + + +static const char* __doc_gr_build_time_enabled_components = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/endianness_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/endianness_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/endianness_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/expj_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/expj_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/expj_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/flowgraph_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/flowgraph_pydoc_template.h new file mode 100644 index 0000000000..ff54686a4a --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/flowgraph_pydoc_template.h @@ -0,0 +1,156 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_flowgraph = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_flowgraph = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_connect_0 = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_disconnect_0 = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_connect_1 = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_disconnect_1 = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_connect_2 = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_disconnect_2 = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_validate = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_clear = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_edges = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_msg_edges = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_calc_used_blocks = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_topological_sort = R"doc()doc"; + + +static const char* __doc_gr_flowgraph_partition = R"doc()doc"; + + +static const char* __doc_gr_endpoint = R"doc()doc"; + + +static const char* __doc_gr_endpoint_endpoint_0 = R"doc()doc"; + + +static const char* __doc_gr_endpoint_endpoint_1 = R"doc()doc"; + + +static const char* __doc_gr_endpoint_endpoint_2 = R"doc()doc"; + + +static const char* __doc_gr_endpoint_block = R"doc()doc"; + + +static const char* __doc_gr_endpoint_port = R"doc()doc"; + + +static const char* __doc_gr_endpoint_identifier = R"doc()doc"; + + +static const char* __doc_gr_msg_endpoint = R"doc()doc"; + + +static const char* __doc_gr_msg_endpoint_msg_endpoint_0 = R"doc()doc"; + + +static const char* __doc_gr_msg_endpoint_msg_endpoint_1 = R"doc()doc"; + + +static const char* __doc_gr_msg_endpoint_msg_endpoint_2 = R"doc()doc"; + + +static const char* __doc_gr_msg_endpoint_block = R"doc()doc"; + + +static const char* __doc_gr_msg_endpoint_port = R"doc()doc"; + + +static const char* __doc_gr_msg_endpoint_is_hier = R"doc()doc"; + + +static const char* __doc_gr_msg_endpoint_set_hier = R"doc()doc"; + + +static const char* __doc_gr_msg_endpoint_identifier = R"doc()doc"; + + +static const char* __doc_gr_edge = R"doc()doc"; + + +static const char* __doc_gr_edge_edge_0 = R"doc()doc"; + + +static const char* __doc_gr_edge_edge_1 = R"doc()doc"; + + +static const char* __doc_gr_edge_edge_2 = R"doc()doc"; + + +static const char* __doc_gr_edge_src = R"doc()doc"; + + +static const char* __doc_gr_edge_dst = R"doc()doc"; + + +static const char* __doc_gr_edge_identifier = R"doc()doc"; + + +static const char* __doc_gr_msg_edge = R"doc()doc"; + + +static const char* __doc_gr_msg_edge_msg_edge_0 = R"doc()doc"; + + +static const char* __doc_gr_msg_edge_msg_edge_1 = R"doc()doc"; + + +static const char* __doc_gr_msg_edge_msg_edge_2 = R"doc()doc"; + + +static const char* __doc_gr_msg_edge_src = R"doc()doc"; + + +static const char* __doc_gr_msg_edge_dst = R"doc()doc"; + + +static const char* __doc_gr_msg_edge_identifier = R"doc()doc"; + + +static const char* __doc_gr_make_flowgraph = R"doc()doc"; + + +static const char* __doc_gr_dot_graph_fg = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/fxpt_nco_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/fxpt_nco_pydoc_template.h new file mode 100644 index 0000000000..a3724fc645 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/fxpt_nco_pydoc_template.h @@ -0,0 +1,84 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_fxpt_nco = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_fxpt_nco_0 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_fxpt_nco_1 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_set_phase = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_adjust_phase = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_set_freq = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_adjust_freq = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_step_0 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_step_1 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_get_phase = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_get_freq = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_sincos_0 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_sincos_1 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_sin_0 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_cos_0 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_sin_1 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_cos_1 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_sin_2 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_cos_2 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_sin_3 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_cos_3 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_cos_4 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_nco_sin_4 = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/fxpt_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/fxpt_pydoc_template.h new file mode 100644 index 0000000000..1631008d09 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/fxpt_pydoc_template.h @@ -0,0 +1,39 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_fxpt = R"doc()doc"; + + +static const char* __doc_gr_fxpt_fxpt_0 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_fxpt_1 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_float_to_fixed = R"doc()doc"; + + +static const char* __doc_gr_fxpt_fixed_to_float = R"doc()doc"; + + +static const char* __doc_gr_fxpt_sin = R"doc()doc"; + + +static const char* __doc_gr_fxpt_cos = R"doc()doc"; + + +static const char* __doc_gr_fxpt_sincos = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/fxpt_vco_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/fxpt_vco_pydoc_template.h new file mode 100644 index 0000000000..1d8b91e973 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/fxpt_vco_pydoc_template.h @@ -0,0 +1,48 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_fxpt_vco = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_fxpt_vco_0 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_fxpt_vco_1 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_set_phase = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_adjust_phase = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_get_phase = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_sincos_0 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_sincos_1 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_cos_0 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_cos_1 = R"doc()doc"; + + +static const char* __doc_gr_fxpt_vco_sin = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/hier_block2_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/hier_block2_pydoc_template.h new file mode 100644 index 0000000000..6c51aba45d --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/hier_block2_pydoc_template.h @@ -0,0 +1,126 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_hier_block2 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_self = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_connect_0 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_connect_1 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_msg_connect_0 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_msg_connect_1 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_msg_disconnect_0 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_msg_disconnect_1 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_disconnect_0 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_disconnect_1 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_disconnect_all = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_lock = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_unlock = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_max_output_buffer = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_set_max_output_buffer_0 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_set_max_output_buffer_1 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_min_output_buffer = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_set_min_output_buffer_0 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_set_min_output_buffer_1 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_flatten = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_to_hier_block2 = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_has_msg_port = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_message_port_is_hier = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_message_port_is_hier_in = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_message_port_is_hier_out = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_message_port_register_hier_in = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_message_port_register_hier_out = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_set_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_unset_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_processor_affinity = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_set_log_level = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_log_level = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_all_min_output_buffer_p = R"doc()doc"; + + +static const char* __doc_gr_hier_block2_all_max_output_buffer_p = R"doc()doc"; + + +static const char* __doc_gr_make_hier_block2 = R"doc()doc"; + + +static const char* __doc_gr_dot_graph = R"doc()doc"; + + +static const char* __doc_gr_cast_to_hier_block2_sptr = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/high_res_timer_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/high_res_timer_pydoc_template.h new file mode 100644 index 0000000000..55409413f7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/high_res_timer_pydoc_template.h @@ -0,0 +1,27 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_high_res_timer_now = R"doc()doc"; + + +static const char* __doc_gr_high_res_timer_now_perfmon = R"doc()doc"; + + +static const char* __doc_gr_high_res_timer_tps = R"doc()doc"; + + +static const char* __doc_gr_high_res_timer_epoch = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/io_signature_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/io_signature_pydoc_template.h new file mode 100644 index 0000000000..643f6a3653 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/io_signature_pydoc_template.h @@ -0,0 +1,45 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_io_signature = R"doc()doc"; + + +static const char* __doc_gr_io_signature_io_signature = R"doc()doc"; + + +static const char* __doc_gr_io_signature_make = R"doc()doc"; + + +static const char* __doc_gr_io_signature_make2 = R"doc()doc"; + + +static const char* __doc_gr_io_signature_make3 = R"doc()doc"; + + +static const char* __doc_gr_io_signature_makev = R"doc()doc"; + + +static const char* __doc_gr_io_signature_min_streams = R"doc()doc"; + + +static const char* __doc_gr_io_signature_max_streams = R"doc()doc"; + + +static const char* __doc_gr_io_signature_sizeof_stream_item = R"doc()doc"; + + +static const char* __doc_gr_io_signature_sizeof_stream_items = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/logger_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/logger_pydoc_template.h new file mode 100644 index 0000000000..84d2e5e9cf --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/logger_pydoc_template.h @@ -0,0 +1,147 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_logger = R"doc()doc"; + + +static const char* __doc_gr_logger_logger_0 = R"doc()doc"; + + +static const char* __doc_gr_logger_logger_1 = R"doc()doc"; + + +static const char* __doc_gr_logger_set_level = R"doc()doc"; + + +static const char* __doc_gr_logger_get_level = R"doc()doc"; + + +static const char* __doc_gr_logger_debug = R"doc()doc"; + + +static const char* __doc_gr_logger_info = R"doc()doc"; + + +static const char* __doc_gr_logger_notice = R"doc()doc"; + + +static const char* __doc_gr_logger_warn = R"doc()doc"; + + +static const char* __doc_gr_logger_error = R"doc()doc"; + + +static const char* __doc_gr_logger_crit = R"doc()doc"; + + +static const char* __doc_gr_logger_alert = R"doc()doc"; + + +static const char* __doc_gr_logger_fatal = R"doc()doc"; + + +static const char* __doc_gr_logger_emerg = R"doc()doc"; + + +static const char* __doc_gr_logger_errorIF = R"doc()doc"; + + +static const char* __doc_gr_logger_log_assert = R"doc()doc"; + + +static const char* __doc_gr_logger_add_console_appender = R"doc()doc"; + + +static const char* __doc_gr_logger_set_console_appender = R"doc()doc"; + + +static const char* __doc_gr_logger_add_file_appender = R"doc()doc"; + + +static const char* __doc_gr_logger_set_file_appender = R"doc()doc"; + + +static const char* __doc_gr_logger_add_rollingfile_appender = R"doc()doc"; + + +static const char* __doc_gr_logger_config = R"doc()doc"; + + +static const char* __doc_gr_logger_config_get_filename = R"doc()doc"; + + +static const char* __doc_gr_logger_config_get_watch_period = R"doc()doc"; + + +static const char* __doc_gr_logger_config_load_config = R"doc()doc"; + + +static const char* __doc_gr_logger_config_stop_watch = R"doc()doc"; + + +static const char* __doc_gr_logger_config_reset_config = R"doc()doc"; + + +static const char* __doc_gr_configure_default_loggers = R"doc()doc"; + + +static const char* __doc_gr_update_logger_alias = R"doc()doc"; + + +static const char* __doc_gr_logger_get_logger = R"doc()doc"; + + +static const char* __doc_gr_logger_load_config = R"doc()doc"; + + +static const char* __doc_gr_logger_reset_config = R"doc()doc"; + + +static const char* __doc_gr_logger_set_level_0 = R"doc()doc"; + + +static const char* __doc_gr_logger_set_level_1 = R"doc()doc"; + + +static const char* __doc_gr_logger_get_level_0 = R"doc()doc"; + + +static const char* __doc_gr_logger_get_level_1 = R"doc()doc"; + + +static const char* __doc_gr_logger_add_appender = R"doc()doc"; + + +static const char* __doc_gr_logger_set_appender = R"doc()doc"; + + +// static const char *__doc_gr_logger_add_console_appender = R"doc()doc"; + + +// static const char *__doc_gr_logger_set_console_appender = R"doc()doc"; + + +// static const char *__doc_gr_logger_add_file_appender = R"doc()doc"; + + +// static const char *__doc_gr_logger_set_file_appender = R"doc()doc"; + + +// static const char *__doc_gr_logger_add_rollingfile_appender = R"doc()doc"; + + +static const char* __doc_gr_logger_get_logger_names = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/math_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/math_pydoc_template.h new file mode 100644 index 0000000000..af352fe0b8 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/math_pydoc_template.h @@ -0,0 +1,75 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_fast_cc_multiply = R"doc()doc"; + + +static const char* __doc_gr_is_power_of_2 = R"doc()doc"; + + +static const char* __doc_gr_fast_atan2f_0 = R"doc()doc"; + + +static const char* __doc_gr_fast_atan2f_1 = R"doc()doc"; + + +static const char* __doc_gr_branchless_clip = R"doc()doc"; + + +static const char* __doc_gr_clip = R"doc()doc"; + + +static const char* __doc_gr_binary_slicer = R"doc()doc"; + + +static const char* __doc_gr_quad_45deg_slicer_0 = R"doc()doc"; + + +static const char* __doc_gr_quad_0deg_slicer_0 = R"doc()doc"; + + +static const char* __doc_gr_quad_45deg_slicer_1 = R"doc()doc"; + + +static const char* __doc_gr_quad_0deg_slicer_1 = R"doc()doc"; + + +static const char* __doc_gr_branchless_binary_slicer = R"doc()doc"; + + +static const char* __doc_gr_branchless_quad_0deg_slicer_0 = R"doc()doc"; + + +static const char* __doc_gr_branchless_quad_0deg_slicer_1 = R"doc()doc"; + + +static const char* __doc_gr_branchless_quad_45deg_slicer_0 = R"doc()doc"; + + +static const char* __doc_gr_branchless_quad_45deg_slicer_1 = R"doc()doc"; + + +static const char* __doc_gr_p2_round_down = R"doc()doc"; + + +static const char* __doc_gr_p2_round_up = R"doc()doc"; + + +static const char* __doc_gr_p2_modulo = R"doc()doc"; + + +static const char* __doc_gr_p2_modulo_neg = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/message_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/message_pydoc_template.h new file mode 100644 index 0000000000..5c9a174a90 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/message_pydoc_template.h @@ -0,0 +1,54 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_message = R"doc()doc"; + + +static const char* __doc_gr_message_message = R"doc()doc"; + + +static const char* __doc_gr_message_make = R"doc()doc"; + + +static const char* __doc_gr_message_make_from_string = R"doc()doc"; + + +static const char* __doc_gr_message_type = R"doc()doc"; + + +static const char* __doc_gr_message_arg1 = R"doc()doc"; + + +static const char* __doc_gr_message_arg2 = R"doc()doc"; + + +static const char* __doc_gr_message_set_type = R"doc()doc"; + + +static const char* __doc_gr_message_set_arg1 = R"doc()doc"; + + +static const char* __doc_gr_message_set_arg2 = R"doc()doc"; + + +static const char* __doc_gr_message_msg = R"doc()doc"; + + +static const char* __doc_gr_message_to_string = R"doc()doc"; + + +static const char* __doc_gr_message_ncurrently_allocated = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/msg_accepter_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/msg_accepter_pydoc_template.h new file mode 100644 index 0000000000..fee326c6a3 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/msg_accepter_pydoc_template.h @@ -0,0 +1,27 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_msg_accepter = R"doc()doc"; + + +static const char* __doc_gr_msg_accepter_msg_accepter_0 = R"doc()doc"; + + +static const char* __doc_gr_msg_accepter_msg_accepter_1 = R"doc()doc"; + + +static const char* __doc_gr_msg_accepter_post = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/msg_handler_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/msg_handler_pydoc_template.h new file mode 100644 index 0000000000..b68f16ec3b --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/msg_handler_pydoc_template.h @@ -0,0 +1,27 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_msg_handler = R"doc()doc"; + + +static const char* __doc_gr_msg_handler_msg_handler_0 = R"doc()doc"; + + +static const char* __doc_gr_msg_handler_msg_handler_1 = R"doc()doc"; + + +static const char* __doc_gr_msg_handler_handle = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/msg_queue_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/msg_queue_pydoc_template.h new file mode 100644 index 0000000000..6626bef81e --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/msg_queue_pydoc_template.h @@ -0,0 +1,51 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_msg_queue = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_msg_queue = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_make = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_handle = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_insert_tail = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_delete_head = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_delete_head_nowait = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_flush = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_empty_p = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_full_p = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_count = R"doc()doc"; + + +static const char* __doc_gr_msg_queue_limit = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/nco_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/nco_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/nco_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/prefs_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/prefs_pydoc_template.h new file mode 100644 index 0000000000..61b0e0f8fb --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/prefs_pydoc_template.h @@ -0,0 +1,63 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_prefs = R"doc()doc"; + + +static const char* __doc_gr_prefs_prefs = R"doc()doc"; + + +static const char* __doc_gr_prefs_singleton = R"doc()doc"; + + +static const char* __doc_gr_prefs_add_config_file = R"doc()doc"; + + +static const char* __doc_gr_prefs_to_string = R"doc()doc"; + + +static const char* __doc_gr_prefs_save = R"doc()doc"; + + +static const char* __doc_gr_prefs_has_section = R"doc()doc"; + + +static const char* __doc_gr_prefs_has_option = R"doc()doc"; + + +static const char* __doc_gr_prefs_get_string = R"doc()doc"; + + +static const char* __doc_gr_prefs_set_string = R"doc()doc"; + + +static const char* __doc_gr_prefs_get_bool = R"doc()doc"; + + +static const char* __doc_gr_prefs_set_bool = R"doc()doc"; + + +static const char* __doc_gr_prefs_get_long = R"doc()doc"; + + +static const char* __doc_gr_prefs_set_long = R"doc()doc"; + + +static const char* __doc_gr_prefs_get_double = R"doc()doc"; + + +static const char* __doc_gr_prefs_set_double = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/random_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/random_pydoc_template.h new file mode 100644 index 0000000000..71fdb84d39 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/random_pydoc_template.h @@ -0,0 +1,51 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_random = R"doc()doc"; + + +static const char* __doc_gr_random_random_0 = R"doc()doc"; + + +static const char* __doc_gr_random_random_1 = R"doc()doc"; + + +static const char* __doc_gr_random_reseed = R"doc()doc"; + + +static const char* __doc_gr_random_set_integer_limits = R"doc()doc"; + + +static const char* __doc_gr_random_ran_int = R"doc()doc"; + + +static const char* __doc_gr_random_ran1 = R"doc()doc"; + + +static const char* __doc_gr_random_gasdev = R"doc()doc"; + + +static const char* __doc_gr_random_laplacian = R"doc()doc"; + + +static const char* __doc_gr_random_rayleigh = R"doc()doc"; + + +static const char* __doc_gr_random_impulse = R"doc()doc"; + + +static const char* __doc_gr_random_rayleigh_complex = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/realtime_impl_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/realtime_impl_pydoc_template.h new file mode 100644 index 0000000000..88724212e3 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/realtime_impl_pydoc_template.h @@ -0,0 +1,39 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_impl_rt_sched_param = R"doc()doc"; + + +static const char* __doc_gr_impl_rt_sched_param_rt_sched_param_0 = R"doc()doc"; + + +static const char* __doc_gr_impl_rt_sched_param_rt_sched_param_1 = R"doc()doc"; + + +static const char* __doc_gr_impl_rt_sched_param_rt_sched_param_2 = R"doc()doc"; + + +static const char* __doc_gr_impl_rt_priority_min = R"doc()doc"; + + +static const char* __doc_gr_impl_rt_priority_max = R"doc()doc"; + + +static const char* __doc_gr_impl_rt_priority_default = R"doc()doc"; + + +static const char* __doc_gr_impl_enable_realtime_scheduling = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/realtime_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/realtime_pydoc_template.h new file mode 100644 index 0000000000..91a9607ae2 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/realtime_pydoc_template.h @@ -0,0 +1,18 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_enable_realtime_scheduling = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpccallbackregister_base_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpccallbackregister_base_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpccallbackregister_base_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcmanager_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcmanager_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcmanager_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcregisterhelpers_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcregisterhelpers_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcregisterhelpers_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcserver_aggregator_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcserver_aggregator_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcserver_aggregator_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcserver_base_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcserver_base_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcserver_base_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcserver_booter_aggregator_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcserver_booter_aggregator_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/rpcserver_booter_aggregator_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/runtime_types_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/runtime_types_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/runtime_types_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sincos_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sincos_pydoc_template.h new file mode 100644 index 0000000000..6d430b5983 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sincos_pydoc_template.h @@ -0,0 +1,21 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_sincos = R"doc()doc"; + + +static const char* __doc_gr_sincosf = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sptr_magic_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sptr_magic_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sptr_magic_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sync_block_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sync_block_pydoc_template.h new file mode 100644 index 0000000000..6034878624 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sync_block_pydoc_template.h @@ -0,0 +1,33 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_sync_block = R"doc()doc"; + + +static const char* __doc_gr_sync_block_work = R"doc()doc"; + + +static const char* __doc_gr_sync_block_forecast = R"doc()doc"; + + +static const char* __doc_gr_sync_block_general_work = R"doc()doc"; + + +static const char* __doc_gr_sync_block_fixed_rate_ninput_to_noutput = R"doc()doc"; + + +static const char* __doc_gr_sync_block_fixed_rate_noutput_to_ninput = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sync_decimator_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sync_decimator_pydoc_template.h new file mode 100644 index 0000000000..f327d9f66e --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sync_decimator_pydoc_template.h @@ -0,0 +1,36 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_sync_decimator = R"doc()doc"; + + +static const char* __doc_gr_sync_decimator_decimation = R"doc()doc"; + + +static const char* __doc_gr_sync_decimator_set_decimation = R"doc()doc"; + + +static const char* __doc_gr_sync_decimator_forecast = R"doc()doc"; + + +static const char* __doc_gr_sync_decimator_general_work = R"doc()doc"; + + +static const char* __doc_gr_sync_decimator_fixed_rate_ninput_to_noutput = R"doc()doc"; + + +static const char* __doc_gr_sync_decimator_fixed_rate_noutput_to_ninput = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sync_interpolator_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sync_interpolator_pydoc_template.h new file mode 100644 index 0000000000..3876790dbd --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sync_interpolator_pydoc_template.h @@ -0,0 +1,36 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_sync_interpolator = R"doc()doc"; + + +static const char* __doc_gr_sync_interpolator_interpolation = R"doc()doc"; + + +static const char* __doc_gr_sync_interpolator_set_interpolation = R"doc()doc"; + + +static const char* __doc_gr_sync_interpolator_forecast = R"doc()doc"; + + +static const char* __doc_gr_sync_interpolator_general_work = R"doc()doc"; + + +static const char* __doc_gr_sync_interpolator_fixed_rate_ninput_to_noutput = R"doc()doc"; + + +static const char* __doc_gr_sync_interpolator_fixed_rate_noutput_to_ninput = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sys_paths_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sys_paths_pydoc_template.h new file mode 100644 index 0000000000..28a857d4cd --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/sys_paths_pydoc_template.h @@ -0,0 +1,24 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_tmp_path = R"doc()doc"; + + +static const char* __doc_gr_appdata_path = R"doc()doc"; + + +static const char* __doc_gr_userconf_path = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tag_checker_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tag_checker_pydoc_template.h new file mode 100644 index 0000000000..29d19d8e0f --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tag_checker_pydoc_template.h @@ -0,0 +1,27 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_tag_checker = R"doc()doc"; + + +static const char* __doc_gr_tag_checker_tag_checker_0 = R"doc()doc"; + + +static const char* __doc_gr_tag_checker_tag_checker_1 = R"doc()doc"; + + +static const char* __doc_gr_tag_checker_get_tags = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tagged_stream_block_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tagged_stream_block_pydoc_template.h new file mode 100644 index 0000000000..efbd93e749 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tagged_stream_block_pydoc_template.h @@ -0,0 +1,30 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_tagged_stream_block = R"doc()doc"; + + +static const char* __doc_gr_tagged_stream_block_forecast = R"doc()doc"; + + +static const char* __doc_gr_tagged_stream_block_check_topology = R"doc()doc"; + + +static const char* __doc_gr_tagged_stream_block_general_work = R"doc()doc"; + + +static const char* __doc_gr_tagged_stream_block_work = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tags_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tags_pydoc_template.h new file mode 100644 index 0000000000..43981ff697 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tags_pydoc_template.h @@ -0,0 +1,27 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_tag_t = R"doc()doc"; + + +static const char* __doc_gr_tag_t_tag_t_0 = R"doc()doc"; + + +static const char* __doc_gr_tag_t_tag_t_1 = R"doc()doc"; + + +static const char* __doc_gr_tag_t_offset_compare = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/thrift_application_base_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/thrift_application_base_pydoc_template.h new file mode 100644 index 0000000000..a17028c0e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/thrift_application_base_pydoc_template.h @@ -0,0 +1,15 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/top_block_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/top_block_pydoc_template.h new file mode 100644 index 0000000000..e93ed7c3ee --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/top_block_pydoc_template.h @@ -0,0 +1,63 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_top_block = R"doc()doc"; + + +static const char* __doc_gr_top_block_run = R"doc()doc"; + + +static const char* __doc_gr_top_block_start = R"doc()doc"; + + +static const char* __doc_gr_top_block_stop = R"doc()doc"; + + +static const char* __doc_gr_top_block_wait = R"doc()doc"; + + +static const char* __doc_gr_top_block_lock = R"doc()doc"; + + +static const char* __doc_gr_top_block_unlock = R"doc()doc"; + + +static const char* __doc_gr_top_block_edge_list = R"doc()doc"; + + +static const char* __doc_gr_top_block_msg_edge_list = R"doc()doc"; + + +static const char* __doc_gr_top_block_dump = R"doc()doc"; + + +static const char* __doc_gr_top_block_max_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_top_block_set_max_noutput_items = R"doc()doc"; + + +static const char* __doc_gr_top_block_to_top_block = R"doc()doc"; + + +static const char* __doc_gr_top_block_setup_rpc = R"doc()doc"; + + +static const char* __doc_gr_make_top_block = R"doc()doc"; + + +static const char* __doc_gr_cast_to_top_block_sptr = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tpb_detail_pydoc_template.h b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tpb_detail_pydoc_template.h new file mode 100644 index 0000000000..2d7b4fa793 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/docstrings/tpb_detail_pydoc_template.h @@ -0,0 +1,36 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(gr, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_gr_tpb_detail = R"doc()doc"; + + +static const char* __doc_gr_tpb_detail_tpb_detail = R"doc()doc"; + + +static const char* __doc_gr_tpb_detail_notify_upstream = R"doc()doc"; + + +static const char* __doc_gr_tpb_detail_notify_downstream = R"doc()doc"; + + +static const char* __doc_gr_tpb_detail_notify_neighbors = R"doc()doc"; + + +static const char* __doc_gr_tpb_detail_notify_msg = R"doc()doc"; + + +static const char* __doc_gr_tpb_detail_clear_changed = R"doc()doc"; diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/endianness_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/endianness_python.cc new file mode 100644 index 0000000000..95d44214c6 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/endianness_python.cc @@ -0,0 +1,35 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(endianness.h) */ +/* BINDTOOL_HEADER_FILE_HASH(1738ddb9b6c9db43eafe4b41583afec0) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/endianness.h> + +void bind_endianness(py::module& m) +{ + + py::enum_<gr::endianness_t>(m, "endianness_t") + .value("GR_MSB_FIRST", gr::GR_MSB_FIRST) // 0 + .value("GR_LSB_FIRST", gr::GR_LSB_FIRST) // 1 + .export_values(); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/expj_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/expj_python.cc new file mode 100644 index 0000000000..b474a65651 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/expj_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(expj.h) */ +/* BINDTOOL_HEADER_FILE_HASH(484853753d87c0ea234a87fec495c36e) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/expj.h> + +void bind_expj(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/flowgraph_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/flowgraph_python.cc new file mode 100644 index 0000000000..6f1f6694ef --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/flowgraph_python.cc @@ -0,0 +1,226 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(flowgraph.h) */ +/* BINDTOOL_HEADER_FILE_HASH(a019dfc2f7380e37ef8eaa0ee96c39c0) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/flowgraph.h> +// pydoc.h is automatically generated in the build directory +#include <flowgraph_pydoc.h> + +void bind_flowgraph(py::module& m) +{ + + using flowgraph = ::gr::flowgraph; + using endpoint = ::gr::endpoint; + using msg_endpoint = ::gr::msg_endpoint; + using edge = ::gr::edge; + using msg_edge = ::gr::msg_edge; + + + py::class_<flowgraph, std::shared_ptr<flowgraph>>(m, "flowgraph", D(flowgraph)) + + .def(py::init<gr::flowgraph const&>(), py::arg("arg0"), D(flowgraph, flowgraph)) + + + .def("connect", + (void (flowgraph::*)(gr::endpoint const&, gr::endpoint const&)) & + flowgraph::connect, + py::arg("src"), + py::arg("dst"), + D(flowgraph, connect, 0)) + + + .def("disconnect", + (void (flowgraph::*)(gr::endpoint const&, gr::endpoint const&)) & + flowgraph::disconnect, + py::arg("src"), + py::arg("dst"), + D(flowgraph, disconnect, 0)) + + + .def("connect", + (void (flowgraph::*)(gr::basic_block_sptr, int, gr::basic_block_sptr, int)) & + flowgraph::connect, + py::arg("src_block"), + py::arg("src_port"), + py::arg("dst_block"), + py::arg("dst_port"), + D(flowgraph, connect, 1)) + + + .def("disconnect", + (void (flowgraph::*)(gr::basic_block_sptr, int, gr::basic_block_sptr, int)) & + flowgraph::disconnect, + py::arg("src_block"), + py::arg("src_port"), + py::arg("dst_block"), + py::arg("dst_port"), + D(flowgraph, disconnect, 1)) + + + .def("connect", + (void (flowgraph::*)(gr::msg_endpoint const&, gr::msg_endpoint const&)) & + flowgraph::connect, + py::arg("src"), + py::arg("dst"), + D(flowgraph, connect, 2)) + + + .def("disconnect", + (void (flowgraph::*)(gr::msg_endpoint const&, gr::msg_endpoint const&)) & + flowgraph::disconnect, + py::arg("src"), + py::arg("dst"), + D(flowgraph, disconnect, 2)) + + + .def("validate", &flowgraph::validate, D(flowgraph, validate)) + + + .def("clear", &flowgraph::clear, D(flowgraph, clear)) + + + .def("edges", &flowgraph::edges, D(flowgraph, edges)) + + + .def("msg_edges", &flowgraph::msg_edges, D(flowgraph, msg_edges)) + + + .def("calc_used_blocks", + &flowgraph::calc_used_blocks, + D(flowgraph, calc_used_blocks)) + + + .def("topological_sort", + &flowgraph::topological_sort, + py::arg("blocks"), + D(flowgraph, topological_sort)) + + + .def("partition", &flowgraph::partition, D(flowgraph, partition)) + + ; + + + py::class_<endpoint, std::shared_ptr<endpoint>>(m, "endpoint", D(endpoint)) + + .def(py::init<>(), D(endpoint, endpoint, 0)) + .def(py::init<gr::basic_block_sptr, int>(), + py::arg("block"), + py::arg("port"), + D(endpoint, endpoint, 1)) + .def(py::init<gr::endpoint const&>(), py::arg("arg0"), D(endpoint, endpoint, 2)) + + + .def("block", &endpoint::block, D(endpoint, block)) + + + .def("port", &endpoint::port, D(endpoint, port)) + + + .def("identifier", &endpoint::identifier, D(endpoint, identifier)) + + ; + + + py::class_<msg_endpoint, std::shared_ptr<msg_endpoint>>( + m, "msg_endpoint", D(msg_endpoint)) + + .def(py::init<>(), D(msg_endpoint, msg_endpoint, 0)) + .def(py::init<gr::basic_block_sptr, pmt::pmt_t, bool>(), + py::arg("block"), + py::arg("port"), + py::arg("is_hier") = false, + D(msg_endpoint, msg_endpoint, 1)) + .def(py::init<gr::msg_endpoint const&>(), + py::arg("arg0"), + D(msg_endpoint, msg_endpoint, 2)) + + + .def("block", &msg_endpoint::block, D(msg_endpoint, block)) + + + .def("port", &msg_endpoint::port, D(msg_endpoint, port)) + + + .def("is_hier", &msg_endpoint::is_hier, D(msg_endpoint, is_hier)) + + + .def("set_hier", &msg_endpoint::set_hier, py::arg("h"), D(msg_endpoint, set_hier)) + + + .def("identifier", &msg_endpoint::identifier, D(msg_endpoint, identifier)) + + ; + + + py::class_<edge, std::shared_ptr<edge>>(m, "edge", D(edge)) + + .def(py::init<>(), D(edge, edge, 0)) + .def(py::init<gr::endpoint const&, gr::endpoint const&>(), + py::arg("src"), + py::arg("dst"), + D(edge, edge, 1)) + .def(py::init<gr::edge const&>(), py::arg("arg0"), D(edge, edge, 2)) + + + .def("src", &edge::src, D(edge, src)) + + + .def("dst", &edge::dst, D(edge, dst)) + + + .def("identifier", &edge::identifier, D(edge, identifier)) + + ; + + + py::class_<msg_edge, std::shared_ptr<msg_edge>>(m, "msg_edge", D(msg_edge)) + + .def(py::init<>(), D(msg_edge, msg_edge, 0)) + .def(py::init<gr::msg_endpoint const&, gr::msg_endpoint const&>(), + py::arg("src"), + py::arg("dst"), + D(msg_edge, msg_edge, 1)) + .def(py::init<gr::msg_edge const&>(), py::arg("arg0"), D(msg_edge, msg_edge, 2)) + + + .def("src", &msg_edge::src, D(msg_edge, src)) + + + .def("dst", &msg_edge::dst, D(msg_edge, dst)) + + + .def("identifier", &msg_edge::identifier, D(msg_edge, identifier)) + + ; + + + m.def("make_flowgraph", &::gr::make_flowgraph, D(make_flowgraph)); + + + // m.def("dot_graph_fg",&::gr::dot_graph_fg, + // py::arg("fg"), + // D(dot_graph_fg) + // ); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/fxpt_nco_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/fxpt_nco_python.cc new file mode 100644 index 0000000000..40cf159870 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/fxpt_nco_python.cc @@ -0,0 +1,161 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(fxpt_nco.h) */ +/* BINDTOOL_HEADER_FILE_HASH(a464f7bdf49d3dfafc989a2b3f4d7b94) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/fxpt_nco.h> +// pydoc.h is automatically generated in the build directory +#include <fxpt_nco_pydoc.h> + +void bind_fxpt_nco(py::module& m) +{ + + using fxpt_nco = ::gr::fxpt_nco; + + + py::class_<fxpt_nco, std::shared_ptr<fxpt_nco>>(m, "fxpt_nco", D(fxpt_nco)) + + .def(py::init<>(), D(fxpt_nco, fxpt_nco, 0)) + .def(py::init<gr::fxpt_nco const&>(), py::arg("arg0"), D(fxpt_nco, fxpt_nco, 1)) + + + .def("set_phase", &fxpt_nco::set_phase, py::arg("angle"), D(fxpt_nco, set_phase)) + + + .def("adjust_phase", + &fxpt_nco::adjust_phase, + py::arg("delta_phase"), + D(fxpt_nco, adjust_phase)) + + + .def( + "set_freq", &fxpt_nco::set_freq, py::arg("angle_rate"), D(fxpt_nco, set_freq)) + + + .def("adjust_freq", + &fxpt_nco::adjust_freq, + py::arg("delta_angle_rate"), + D(fxpt_nco, adjust_freq)) + + + .def("step", (void (fxpt_nco::*)()) & fxpt_nco::step, D(fxpt_nco, step, 0)) + + + .def("step", + (void (fxpt_nco::*)(int)) & fxpt_nco::step, + py::arg("n"), + D(fxpt_nco, step, 1)) + + + .def("get_phase", &fxpt_nco::get_phase, D(fxpt_nco, get_phase)) + + + .def("get_freq", &fxpt_nco::get_freq, D(fxpt_nco, get_freq)) + + + .def("sincos", + (void (fxpt_nco::*)(float*, float*) const) & fxpt_nco::sincos, + py::arg("sinx"), + py::arg("cosx"), + D(fxpt_nco, sincos, 0)) + + + .def("sincos", + (void (fxpt_nco::*)(gr_complex*, int, double)) & fxpt_nco::sincos, + py::arg("output"), + py::arg("noutput_items"), + py::arg("ampl") = 1., + D(fxpt_nco, sincos, 1)) + + + .def("sin", + (void (fxpt_nco::*)(float*, int, double)) & fxpt_nco::sin, + py::arg("output"), + py::arg("noutput_items"), + py::arg("ampl") = 1., + D(fxpt_nco, sin, 0)) + + + .def("cos", + (void (fxpt_nco::*)(float*, int, double)) & fxpt_nco::cos, + py::arg("output"), + py::arg("noutput_items"), + py::arg("ampl") = 1., + D(fxpt_nco, cos, 0)) + + + .def("sin", + (void (fxpt_nco::*)(int8_t*, int, double)) & fxpt_nco::sin, + py::arg("output"), + py::arg("noutput_items"), + py::arg("ampl") = 1., + D(fxpt_nco, sin, 1)) + + + .def("cos", + (void (fxpt_nco::*)(int8_t*, int, double)) & fxpt_nco::cos, + py::arg("output"), + py::arg("noutput_items"), + py::arg("ampl") = 1., + D(fxpt_nco, cos, 1)) + + + .def("sin", + (void (fxpt_nco::*)(short int*, int, double)) & fxpt_nco::sin, + py::arg("output"), + py::arg("noutput_items"), + py::arg("ampl") = 1., + D(fxpt_nco, sin, 2)) + + + .def("cos", + (void (fxpt_nco::*)(short int*, int, double)) & fxpt_nco::cos, + py::arg("output"), + py::arg("noutput_items"), + py::arg("ampl") = 1., + D(fxpt_nco, cos, 2)) + + + .def("sin", + (void (fxpt_nco::*)(int*, int, double)) & fxpt_nco::sin, + py::arg("output"), + py::arg("noutput_items"), + py::arg("ampl") = 1., + D(fxpt_nco, sin, 3)) + + + .def("cos", + (void (fxpt_nco::*)(int*, int, double)) & fxpt_nco::cos, + py::arg("output"), + py::arg("noutput_items"), + py::arg("ampl") = 1., + D(fxpt_nco, cos, 3)) + + + .def("cos", (float (fxpt_nco::*)() const) & fxpt_nco::cos, D(fxpt_nco, cos, 4)) + + + .def("sin", (float (fxpt_nco::*)() const) & fxpt_nco::sin, D(fxpt_nco, sin, 4)) + + ; +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/fxpt_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/fxpt_python.cc new file mode 100644 index 0000000000..52ef1f249c --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/fxpt_python.cc @@ -0,0 +1,68 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(fxpt.h) */ +/* BINDTOOL_HEADER_FILE_HASH(d8f127eabbf6b31d6fb100ad04eb21b2) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/fxpt.h> +// pydoc.h is automatically generated in the build directory +#include <fxpt_pydoc.h> + +void bind_fxpt(py::module& m) +{ + + using fxpt = ::gr::fxpt; + + + py::class_<fxpt, std::shared_ptr<fxpt>>(m, "fxpt", D(fxpt)) + + .def(py::init<>(), D(fxpt, fxpt, 0)) + .def(py::init<gr::fxpt const&>(), py::arg("arg0"), D(fxpt, fxpt, 1)) + + + .def_static("float_to_fixed", + &fxpt::float_to_fixed, + py::arg("x"), + D(fxpt, float_to_fixed)) + + + .def_static("fixed_to_float", + &fxpt::fixed_to_float, + py::arg("x"), + D(fxpt, fixed_to_float)) + + + .def_static("sin", &fxpt::sin, py::arg("x"), D(fxpt, sin)) + + + .def_static("cos", &fxpt::cos, py::arg("x"), D(fxpt, cos)) + + + .def_static("sincos", + &fxpt::sincos, + py::arg("x"), + py::arg("s"), + py::arg("c"), + D(fxpt, sincos)) + + ; +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/fxpt_vco_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/fxpt_vco_python.cc new file mode 100644 index 0000000000..1e0fc38753 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/fxpt_vco_python.cc @@ -0,0 +1,89 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(fxpt_vco.h) */ +/* BINDTOOL_HEADER_FILE_HASH(e43dce3c6a7df7cd2c1ff929cc6eabb1) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/fxpt_vco.h> +// pydoc.h is automatically generated in the build directory +#include <fxpt_vco_pydoc.h> + +void bind_fxpt_vco(py::module& m) +{ + + using fxpt_vco = ::gr::fxpt_vco; + + + py::class_<fxpt_vco, std::shared_ptr<fxpt_vco>>(m, "fxpt_vco", D(fxpt_vco)) + + .def(py::init<>(), D(fxpt_vco, fxpt_vco, 0)) + .def(py::init<gr::fxpt_vco const&>(), py::arg("arg0"), D(fxpt_vco, fxpt_vco, 1)) + + + .def("set_phase", &fxpt_vco::set_phase, py::arg("angle"), D(fxpt_vco, set_phase)) + + + .def("adjust_phase", + &fxpt_vco::adjust_phase, + py::arg("delta_phase"), + D(fxpt_vco, adjust_phase)) + + + .def("get_phase", &fxpt_vco::get_phase, D(fxpt_vco, get_phase)) + + + .def("sincos", + (void (fxpt_vco::*)(float*, float*) const) & fxpt_vco::sincos, + py::arg("sinx"), + py::arg("cosx"), + D(fxpt_vco, sincos, 0)) + + + .def("sincos", + (void (fxpt_vco::*)(gr_complex*, float const*, int, float, float)) & + fxpt_vco::sincos, + py::arg("output"), + py::arg("input"), + py::arg("noutput_items"), + py::arg("k"), + py::arg("ampl") = 1., + D(fxpt_vco, sincos, 1)) + + + .def("cos", + (void (fxpt_vco::*)(float*, float const*, int, float, float)) & + fxpt_vco::cos, + py::arg("output"), + py::arg("input"), + py::arg("noutput_items"), + py::arg("k"), + py::arg("ampl") = 1., + D(fxpt_vco, cos, 0)) + + + .def("cos", (float (fxpt_vco::*)() const) & fxpt_vco::cos, D(fxpt_vco, cos, 1)) + + + .def("sin", &fxpt_vco::sin, D(fxpt_vco, sin)) + + ; +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/hier_block2_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/hier_block2_python.cc new file mode 100644 index 0000000000..f2d439ad52 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/hier_block2_python.cc @@ -0,0 +1,227 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(hier_block2.h) */ +/* BINDTOOL_HEADER_FILE_HASH(367d4df8d747ae4040c2e5b46cbe1b4f) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/hier_block2.h> +// pydoc.h is automatically generated in the build directory +#include <hier_block2_pydoc.h> + +void bind_hier_block2(py::module& m) +{ + + using hier_block2 = ::gr::hier_block2; + + py::class_<hier_block2, + gr::basic_block, + gr::msg_accepter, + std::shared_ptr<hier_block2>>(m, "hier_block2_pb", D(hier_block2)) + + .def(py::init(&gr::make_hier_block2), + py::arg("name"), + py::arg("input_signature"), + py::arg("output_signature")) + + .def("self", &hier_block2::self) + .def("primitive_connect", + (void (hier_block2::*)(gr::basic_block_sptr)) & hier_block2::connect, + py::arg("block")) + .def("primitive_connect", + (void (hier_block2::*)( + gr::basic_block_sptr, int, gr::basic_block_sptr, int)) & + hier_block2::connect, + py::arg("src"), + py::arg("src_port"), + py::arg("dst"), + py::arg("dst_port"), + D(hier_block2, connect, 1)) + .def("primitive_msg_connect", + (void (hier_block2::*)( + gr::basic_block_sptr, pmt::pmt_t, gr::basic_block_sptr, pmt::pmt_t)) & + hier_block2::msg_connect, + py::arg("src"), + py::arg("srcport"), + py::arg("dst"), + py::arg("dstport"), + D(hier_block2, msg_connect, 0)) + .def("primitive_msg_connect", + (void (hier_block2::*)( + gr::basic_block_sptr, std::string, gr::basic_block_sptr, std::string)) & + hier_block2::msg_connect, + py::arg("src"), + py::arg("srcport"), + py::arg("dst"), + py::arg("dstport"), + D(hier_block2, msg_connect, 1)) + .def("primitive_msg_disconnect", + (void (hier_block2::*)( + gr::basic_block_sptr, pmt::pmt_t, gr::basic_block_sptr, pmt::pmt_t)) & + hier_block2::msg_disconnect, + py::arg("src"), + py::arg("srcport"), + py::arg("dst"), + py::arg("dstport"), + D(hier_block2, msg_disconnect, 0)) + .def("primitive_msg_disconnect", + (void (hier_block2::*)( + gr::basic_block_sptr, std::string, gr::basic_block_sptr, std::string)) & + hier_block2::msg_disconnect, + py::arg("src"), + py::arg("srcport"), + py::arg("dst"), + py::arg("dstport"), + D(hier_block2, msg_disconnect, 1)) + .def("primitive_disconnect", + (void (hier_block2::*)(gr::basic_block_sptr)) & hier_block2::disconnect, + py::arg("block"), + D(hier_block2, disconnect, 0)) + .def("primitive_disconnect", + (void (hier_block2::*)( + gr::basic_block_sptr, int, gr::basic_block_sptr, int)) & + hier_block2::disconnect, + py::arg("src"), + py::arg("src_port"), + py::arg("dst"), + py::arg("dst_port"), + D(hier_block2, disconnect, 1)) + + + .def("disconnect_all", + &hier_block2::disconnect_all, + D(hier_block2, disconnect_all)) + + + .def("lock", &hier_block2::lock, D(hier_block2, lock)) + + + .def("unlock", &hier_block2::unlock, D(hier_block2, unlock)) + + + .def("max_output_buffer", + &hier_block2::max_output_buffer, + py::arg("port") = 0, + D(hier_block2, max_output_buffer)) + .def("set_max_output_buffer", + (void (hier_block2::*)(int)) & hier_block2::set_max_output_buffer, + py::arg("max_output_buffer"), + D(hier_block2, set_max_output_buffer, 0)) + .def("set_max_output_buffer", + (void (hier_block2::*)(size_t, int)) & hier_block2::set_max_output_buffer, + py::arg("port"), + py::arg("max_output_buffer"), + D(hier_block2, set_max_output_buffer, 1)) + .def("min_output_buffer", + &hier_block2::min_output_buffer, + py::arg("port") = 0, + D(hier_block2, min_output_buffer)) + .def("set_min_output_buffer", + (void (hier_block2::*)(int)) & hier_block2::set_min_output_buffer, + py::arg("min_output_buffer"), + D(hier_block2, set_min_output_buffer, 0)) + .def("set_min_output_buffer", + (void (hier_block2::*)(size_t, int)) & hier_block2::set_min_output_buffer, + py::arg("port"), + py::arg("min_output_buffer"), + D(hier_block2, set_min_output_buffer, 1)) + // .def("flatten",&hier_block2::flatten) + .def("to_hier_block2", + &hier_block2::to_hier_block2, + D(hier_block2, to_hier_block2)) + + .def("has_msg_port", + &hier_block2::has_msg_port, + py::arg("which_port"), + D(hier_block2, has_msg_port)) + .def("message_port_is_hier", + &hier_block2::message_port_is_hier, + py::arg("port_id"), + D(hier_block2, message_port_is_hier)) + .def("message_port_is_hier_in", + &hier_block2::message_port_is_hier_in, + py::arg("port_id"), + D(hier_block2, message_port_is_hier_in)) + .def("message_port_is_hier_out", + &hier_block2::message_port_is_hier_out, + py::arg("port_id"), + D(hier_block2, message_port_is_hier_out)) + + + .def("primitive_message_port_register_hier_in", + &hier_block2::message_port_register_hier_in, + py::arg("port_id"), + D(hier_block2, message_port_register_hier_in)) + + + .def("primitive_message_port_register_hier_out", + &hier_block2::message_port_register_hier_out, + py::arg("port_id"), + D(hier_block2, message_port_register_hier_out)) + .def("set_processor_affinity", + &hier_block2::set_processor_affinity, + py::arg("mask"), + D(hier_block2, set_processor_affinity)) + + + .def("unset_processor_affinity", + &hier_block2::unset_processor_affinity, + D(hier_block2, unset_processor_affinity)) + + + .def("processor_affinity", + &hier_block2::processor_affinity, + D(hier_block2, processor_affinity)) + + + .def("set_log_level", + &hier_block2::set_log_level, + py::arg("level"), + D(hier_block2, set_log_level)) + + + .def("log_level", &hier_block2::log_level, D(hier_block2, log_level)) + + + .def("all_min_output_buffer_p", + &hier_block2::all_min_output_buffer_p, + D(hier_block2, all_min_output_buffer_p)) + + + .def("all_max_output_buffer_p", + &hier_block2::all_max_output_buffer_p, + D(hier_block2, all_max_output_buffer_p)) + + ; + + + // m.def("make_hier_block2",&gr::make_hier_block2, + // py::arg("name"), + // py::arg("input_signature"), + // py::arg("output_signature") + // ); + // m.def("dot_graph",&gr::dot_graph, + // py::arg("hierblock2") + // ); + // m.def("cast_to_hier_block2_sptr",&gr::cast_to_hier_block2_sptr, + // py::arg("block") + // ); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/high_res_timer_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/high_res_timer_python.cc new file mode 100644 index 0000000000..4e581bfc98 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/high_res_timer_python.cc @@ -0,0 +1,46 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(high_res_timer.h) */ +/* BINDTOOL_HEADER_FILE_HASH(07d128321042e69a0ce418de407ceaf4) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/high_res_timer.h> +// pydoc.h is automatically generated in the build directory +#include <high_res_timer_pydoc.h> + +void bind_high_res_timer(py::module& m) +{ + + + m.def("high_res_timer_now", &::gr::high_res_timer_now, D(high_res_timer_now)); + + + m.def("high_res_timer_now_perfmon", + &::gr::high_res_timer_now_perfmon, + D(high_res_timer_now_perfmon)); + + + m.def("high_res_timer_tps", &::gr::high_res_timer_tps, D(high_res_timer_tps)); + + + m.def("high_res_timer_epoch", &::gr::high_res_timer_epoch, D(high_res_timer_epoch)); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/io_signature_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/io_signature_python.cc new file mode 100644 index 0000000000..56ed5c2fe5 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/io_signature_python.cc @@ -0,0 +1,90 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(io_signature.h) */ +/* BINDTOOL_HEADER_FILE_HASH(aa246441b45c1a5b872509ed410615ae) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/io_signature.h> +// pydoc.h is automatically generated in the build directory +#include <io_signature_pydoc.h> + +void bind_io_signature(py::module& m) +{ + + using io_signature = ::gr::io_signature; + + + py::class_<io_signature, std::shared_ptr<io_signature>>( + m, "io_signature", D(io_signature)) + + .def(py::init(&io_signature::make), + py::arg("min_streams"), + py::arg("max_streams"), + py::arg("sizeof_stream_item"), + D(io_signature, make)) + + + .def_static("make2", + &io_signature::make2, + py::arg("min_streams"), + py::arg("max_streams"), + py::arg("sizeof_stream_item1"), + py::arg("sizeof_stream_item2"), + D(io_signature, make2)) + + + .def_static("make3", + &io_signature::make3, + py::arg("min_streams"), + py::arg("max_streams"), + py::arg("sizeof_stream_item1"), + py::arg("sizeof_stream_item2"), + py::arg("sizeof_stream_item3"), + D(io_signature, make3)) + + + .def_static("makev", + &io_signature::makev, + py::arg("min_streams"), + py::arg("max_streams"), + py::arg("sizeof_stream_items"), + D(io_signature, makev)) + + + .def("min_streams", &io_signature::min_streams, D(io_signature, min_streams)) + + + .def("max_streams", &io_signature::max_streams, D(io_signature, max_streams)) + + + .def("sizeof_stream_item", + &io_signature::sizeof_stream_item, + py::arg("index"), + D(io_signature, sizeof_stream_item)) + + + .def("sizeof_stream_items", + &io_signature::sizeof_stream_items, + D(io_signature, sizeof_stream_items)) + + ; +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/logger_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/logger_python.cc new file mode 100644 index 0000000000..e97c50bcf1 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/logger_python.cc @@ -0,0 +1,162 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(logger.h) */ +/* BINDTOOL_HEADER_FILE_HASH(5e612fbda6f51ed261021bd090eb95c1) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/logger.h> + +void bind_logger(py::module& m) +{ + using logger = gr::logger; + using logger_config = gr::logger_config; + + + py::class_<logger, std::shared_ptr<logger>>(m, "logger") + + .def(py::init<std::string>(), py::arg("logger_name")) + .def(py::init<gr::logger const&>(), py::arg("arg0")) + + .def("set_level", &logger::set_level, py::arg("level")) + .def("get_level", &logger::get_level, py::arg("level")) + .def("debug", &logger::debug, py::arg("msg")) + .def("info", &logger::info, py::arg("msg")) + .def("notice", &logger::notice, py::arg("msg")) + .def("warn", &logger::warn, py::arg("msg")) + .def("error", &logger::error, py::arg("msg")) + .def("crit", &logger::crit, py::arg("msg")) + .def("alert", &logger::alert, py::arg("msg")) + .def("fatal", &logger::fatal, py::arg("msg")) + .def("emerg", &logger::emerg, py::arg("msg")) + .def("errorIF", &logger::errorIF, py::arg("cond"), py::arg("msg")) + .def("log_assert", &logger::log_assert, py::arg("cond"), py::arg("msg")) + .def("add_console_appender", + &logger::add_console_appender, + py::arg("target"), + py::arg("pattern")) + .def("set_console_appender", + &logger::set_console_appender, + py::arg("target"), + py::arg("pattern")) + .def("add_file_appender", + &logger::add_file_appender, + py::arg("filename"), + py::arg("append"), + py::arg("pattern")) + .def("set_file_appender", + &logger::set_file_appender, + py::arg("filename"), + py::arg("append"), + py::arg("pattern")) + .def("add_rollingfile_appender", + &logger::add_rollingfile_appender, + py::arg("filename"), + py::arg("filesize"), + py::arg("bkup_index"), + py::arg("append"), + py::arg("mode"), + py::arg("pattern")); + + + py::class_<logger_config, std::shared_ptr<logger_config>>(m, "logger_config") + + + .def_static("get_filename", &logger_config::get_filename) + .def_static("get_watch_period", &logger_config::get_watch_period) + .def_static("load_config", + &logger_config::load_config, + py::arg("filename"), + py::arg("watch_period") = 0) + .def_static("stop_watch", &logger_config::stop_watch) + .def_static("reset_config", &logger_config::reset_config); + + + // m.def("configure_default_loggers",&gr::configure_default_loggers, + // py::arg("l"), + // py::arg("d"), + // py::arg("name") + // ); + m.def("update_logger_alias", + &gr::update_logger_alias, + py::arg("name"), + py::arg("alias")); + m.def("logger_get_logger", &gr::logger_get_logger, py::arg("name")); + m.def("logger_load_config", &gr::logger_load_config, py::arg("config_filename") = ""); + m.def("gr_logger_reset_config", &gr_logger_reset_config); + m.def("logger_set_level", + (void (*)(gr::logger_ptr, std::string const&)) & gr::logger_set_level, + py::arg("logger"), + py::arg("level")); + m.def("logger_set_level", + (void (*)(gr::logger_ptr, log4cpp::Priority::Value)) & gr::logger_set_level, + py::arg("logger"), + py::arg("level")); + m.def("logger_get_level", + (void (*)(gr::logger_ptr, std::string&)) & gr::logger_get_level, + py::arg("logger"), + py::arg("level")); + // m.def("logger_get_level",(void (*)(gr::logger_ptr, log4cpp::Priority::Value + // &))&gr::logger_get_level, + // py::arg("logger"), + // py::arg("level") + // ); + // m.def("logger_add_appender",&gr::logger_add_appender, + // py::arg("logger"), + // py::arg("appender") + // ); // Not Implemented + // m.def("logger_set_appender",&gr::logger_set_appender, + // py::arg("logger"), + // py::arg("appender") + // ); // Not Implemented + m.def("logger_add_console_appender", + &gr::logger_add_console_appender, + py::arg("logger"), + py::arg("target"), + py::arg("pattern")); + m.def("logger_set_console_appender", + &gr::logger_set_console_appender, + py::arg("logger"), + py::arg("target"), + py::arg("pattern")); + m.def("logger_add_file_appender", + &gr::logger_add_file_appender, + py::arg("logger"), + py::arg("filename"), + py::arg("append"), + py::arg("pattern")); + m.def("logger_set_file_appender", + &gr::logger_set_file_appender, + py::arg("logger"), + py::arg("filename"), + py::arg("append"), + py::arg("pattern")); + m.def("logger_add_rollingfile_appender", + &gr::logger_add_rollingfile_appender, + py::arg("logger"), + py::arg("filename"), + py::arg("filesize"), + py::arg("bkup_index"), + py::arg("append"), + py::arg("mode"), + py::arg("pattern")); + m.def("logger_get_logger_names", &gr::logger_get_logger_names); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/math_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/math_python.cc new file mode 100644 index 0000000000..5ce47517a8 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/math_python.cc @@ -0,0 +1,148 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(math.h) */ +/* BINDTOOL_HEADER_FILE_HASH(85ba2e8e7191733cc35f70005e2d99e9) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/math.h> +// pydoc.h is automatically generated in the build directory +#include <math_pydoc.h> + +void bind_math(py::module& m) +{ + + + m.def("fast_cc_multiply", + &::gr::fast_cc_multiply, + py::arg("out"), + py::arg("cc1"), + py::arg("cc2"), + D(fast_cc_multiply)); + + + m.def("is_power_of_2", &::gr::is_power_of_2, py::arg("x"), D(is_power_of_2)); + + + m.def("fast_atan2f", + (float (*)(float, float)) & ::gr::fast_atan2f, + py::arg("y"), + py::arg("x"), + D(fast_atan2f, 0)); + + + m.def("fast_atan2f", + (float (*)(gr_complex)) & ::gr::fast_atan2f, + py::arg("z"), + D(fast_atan2f, 1)); + + + m.def("branchless_clip", + &::gr::branchless_clip, + py::arg("x"), + py::arg("clip"), + D(branchless_clip)); + + + m.def("clip", &::gr::clip, py::arg("x"), py::arg("clip"), D(clip)); + + + m.def("binary_slicer", &::gr::binary_slicer, py::arg("x"), D(binary_slicer)); + + + m.def("quad_45deg_slicer", + (unsigned int (*)(float, float)) & ::gr::quad_45deg_slicer, + py::arg("r"), + py::arg("i"), + D(quad_45deg_slicer, 0)); + + + m.def("quad_0deg_slicer", + (unsigned int (*)(float, float)) & ::gr::quad_0deg_slicer, + py::arg("r"), + py::arg("i"), + D(quad_0deg_slicer, 0)); + + + m.def("quad_45deg_slicer", + (unsigned int (*)(gr_complex)) & ::gr::quad_45deg_slicer, + py::arg("x"), + D(quad_45deg_slicer, 1)); + + + m.def("quad_0deg_slicer", + (unsigned int (*)(gr_complex)) & ::gr::quad_0deg_slicer, + py::arg("x"), + D(quad_0deg_slicer, 1)); + + + m.def("branchless_binary_slicer", + &::gr::branchless_binary_slicer, + py::arg("x"), + D(branchless_binary_slicer)); + + + m.def("branchless_quad_0deg_slicer", + (unsigned int (*)(float, float)) & ::gr::branchless_quad_0deg_slicer, + py::arg("r"), + py::arg("i"), + D(branchless_quad_0deg_slicer, 0)); + + + m.def("branchless_quad_0deg_slicer", + (unsigned int (*)(gr_complex)) & ::gr::branchless_quad_0deg_slicer, + py::arg("x"), + D(branchless_quad_0deg_slicer, 1)); + + + m.def("branchless_quad_45deg_slicer", + (unsigned int (*)(float, float)) & ::gr::branchless_quad_45deg_slicer, + py::arg("r"), + py::arg("i"), + D(branchless_quad_45deg_slicer, 0)); + + + m.def("branchless_quad_45deg_slicer", + (unsigned int (*)(gr_complex)) & ::gr::branchless_quad_45deg_slicer, + py::arg("x"), + D(branchless_quad_45deg_slicer, 1)); + + + m.def("p2_round_down", + &::gr::p2_round_down, + py::arg("x"), + py::arg("pow2"), + D(p2_round_down)); + + + m.def( + "p2_round_up", &::gr::p2_round_up, py::arg("x"), py::arg("pow2"), D(p2_round_up)); + + + m.def("p2_modulo", &::gr::p2_modulo, py::arg("x"), py::arg("pow2"), D(p2_modulo)); + + + m.def("p2_modulo_neg", + &::gr::p2_modulo_neg, + py::arg("x"), + py::arg("pow2"), + D(p2_modulo_neg)); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/message_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/message_python.cc new file mode 100644 index 0000000000..05d18d7234 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/message_python.cc @@ -0,0 +1,91 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(message.h) */ +/* BINDTOOL_HEADER_FILE_HASH(1cbfd41a5d35bd455fea4eb0ec792379) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/message.h> +// pydoc.h is automatically generated in the build directory +#include <message_pydoc.h> + +void bind_message(py::module& m) +{ + + using message = ::gr::message; + + + py::class_<message, std::shared_ptr<message>>(m, "message", D(message)) + + .def(py::init(&message::make), + py::arg("type") = 0, + py::arg("arg1") = 0, + py::arg("arg2") = 0, + py::arg("length") = 0, + D(message, make)) + + + .def_static("make_from_string", + &message::make_from_string, + py::arg("s"), + py::arg("type") = 0, + py::arg("arg1") = 0, + py::arg("arg2") = 0, + D(message, make_from_string)) + + + .def("type", &message::type, D(message, type)) + + + .def("arg1", &message::arg1, D(message, arg1)) + + + .def("arg2", &message::arg2, D(message, arg2)) + + + .def("set_type", &message::set_type, py::arg("type"), D(message, set_type)) + .def("set_arg1", &message::set_arg1, py::arg("arg1"), D(message, set_arg1)) + .def("set_arg2", &message::set_arg2, py::arg("arg2"), D(message, set_arg2)) + .def("msg", &message::msg, D(message, msg)) + + .def("length", &message::length) + // .def("to_string",&message::to_string) + // pybind11 needs explicit conversion to handle non-utf8 strings + .def("to_string", + [](std::shared_ptr<message> msg) { + std::string s = msg->to_string(); + return py::bytes(s); // Return the data without transcoding + }) + + + ; + + + m.def("message_ncurrently_allocated", + &::gr::message_ncurrently_allocated, + D(message_ncurrently_allocated)); + m.def("message_from_string", + &message::make_from_string, + py::arg("s"), + py::arg("type") = 0, + py::arg("arg1") = 0, + py::arg("arg2") = 0); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_accepter_msgq_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_accepter_msgq_python.cc new file mode 100644 index 0000000000..57069f3f64 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_accepter_msgq_python.cc @@ -0,0 +1,33 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/messages/msg_accepter_msgq.h> + +void bind_messages_msg_accepter_msgq(py::module& m) +{ + using msg_accepter_msgq = gr::messages::msg_accepter_msgq; + + + py::class_<msg_accepter_msgq, std::shared_ptr<msg_accepter_msgq>>( + m, "messages_msg_accepter_msgq") + + .def(py::init<gr::messages::msg_queue_sptr>(), py::arg("msgq")) + .def(py::init<gr::messages::msg_accepter_msgq const&>(), py::arg("arg0")) + + .def("post", &msg_accepter_msgq::post, py::arg("msg")) + .def("msg_queue", &msg_accepter_msgq::msg_queue); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_accepter_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_accepter_python.cc new file mode 100644 index 0000000000..fbad2e5eea --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_accepter_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/messages/msg_accepter.h> + +void bind_messages_msg_accepter(py::module& m) +{ + using msg_accepter = gr::messages::msg_accepter; + + + py::class_<msg_accepter, std::shared_ptr<msg_accepter>>(m, "messages_msg_accepter") + + .def("post", &msg_accepter::post, py::arg("which_port"), py::arg("msg")); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_passing_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_passing_python.cc new file mode 100644 index 0000000000..3564530a88 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_passing_python.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/messages/msg_passing.h> + +void bind_messages_msg_passing(py::module& m) +{ + + + m.def("send", + (pmt::pmt_t(*)( + gr::messages::msg_accepter_sptr, pmt::pmt_t const&, pmt::pmt_t const&)) & + gr::messages::send, + py::arg("accepter"), + py::arg("which_port"), + py::arg("msg")); + m.def("send", + (pmt::pmt_t(*)( + gr::messages::msg_accepter*, pmt::pmt_t const&, pmt::pmt_t const&)) & + gr::messages::send, + py::arg("accepter"), + py::arg("which_port"), + py::arg("msg")); + m.def("send", + (pmt::pmt_t(*)( + gr::messages::msg_accepter&, pmt::pmt_t const&, pmt::pmt_t const&)) & + gr::messages::send, + py::arg("accepter"), + py::arg("which_port"), + py::arg("msg")); + m.def("send", + (pmt::pmt_t(*)(pmt::pmt_t, pmt::pmt_t const&, pmt::pmt_t const&)) & + gr::messages::send, + py::arg("accepter"), + py::arg("which_port"), + py::arg("msg")); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_producer_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_producer_python.cc new file mode 100644 index 0000000000..d519247ea3 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_producer_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/messages/msg_producer.h> + +void bind_messages_msg_producer(py::module& m) +{ + using msg_producer = gr::messages::msg_producer; + + + py::class_<msg_producer, std::shared_ptr<msg_producer>>(m, "messages_msg_producer") + + .def("retrieve", &msg_producer::retrieve); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_queue_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_queue_python.cc new file mode 100644 index 0000000000..c44a75b3c8 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/messages/msg_queue_python.cc @@ -0,0 +1,42 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/messages/msg_queue.h> + +void bind_messages_msg_queue(py::module& m) +{ + using msg_queue = gr::messages::msg_queue; + + + py::class_<msg_queue, std::shared_ptr<msg_queue>>(m, "messages_msg_queue") + + .def(py::init<unsigned int>(), py::arg("limit")) + + .def("insert_tail", &msg_queue::insert_tail, py::arg("msg")) + .def("delete_head", &msg_queue::delete_head) + .def("delete_head_nowait", &msg_queue::delete_head_nowait) + .def("flush", &msg_queue::flush) + .def("empty_p", &msg_queue::empty_p) + .def("full_p", &msg_queue::full_p) + .def("count", &msg_queue::count) + .def("limit", &msg_queue::limit); + + + // m.def("make_msg_queue",&gr::messages::make_msg_queue, + // py::arg("limit") = 0 + // ); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/msg_accepter_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/msg_accepter_python.cc new file mode 100644 index 0000000000..7b19d9d796 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/msg_accepter_python.cc @@ -0,0 +1,55 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(msg_accepter.h) */ +/* BINDTOOL_HEADER_FILE_HASH(0816b1746a9c1a6dfa996b047917f9c1) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/msg_accepter.h> +// pydoc.h is automatically generated in the build directory +#include <msg_accepter_pydoc.h> + +void bind_msg_accepter(py::module& m) +{ + + using msg_accepter = ::gr::msg_accepter; + + + py::class_<msg_accepter, gr::messages::msg_accepter, std::shared_ptr<msg_accepter>>( + m, "msg_accepter", D(msg_accepter)) + + .def(py::init<>(), D(msg_accepter, msg_accepter, 0)) + .def(py::init<gr::msg_accepter const&>(), + py::arg("arg0"), + D(msg_accepter, msg_accepter, 1)) + + + .def("post", + &msg_accepter::post, + py::arg("which_port"), + py::arg("msg"), + D(msg_accepter, post)) + + ; + + + py::module m_messages = m.def_submodule("messages"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/msg_handler_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/msg_handler_python.cc new file mode 100644 index 0000000000..9aa4c9b57c --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/msg_handler_python.cc @@ -0,0 +1,48 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(msg_handler.h) */ +/* BINDTOOL_HEADER_FILE_HASH(bd8c6ca9906efe1a5be8fb8e5965a7b2) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/msg_handler.h> +// pydoc.h is automatically generated in the build directory +#include <msg_handler_pydoc.h> + +void bind_msg_handler(py::module& m) +{ + + using msg_handler = ::gr::msg_handler; + + + py::class_<msg_handler, std::shared_ptr<msg_handler>>( + m, "msg_handler", D(msg_handler)) + + // .def(py::init<>(),D(msg_handler,msg_handler,0)) + // .def(py::init<gr::msg_handler const &>(), py::arg("arg0"), + // D(msg_handler,msg_handler,1) + // ) + + + .def("handle", &msg_handler::handle, py::arg("msg"), D(msg_handler, handle)) + + ; +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/msg_queue_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/msg_queue_python.cc new file mode 100644 index 0000000000..1e58029429 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/msg_queue_python.cc @@ -0,0 +1,77 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(msg_queue.h) */ +/* BINDTOOL_HEADER_FILE_HASH(0abeb5846ed511d2b4dd13479458f4be) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/msg_queue.h> +// pydoc.h is automatically generated in the build directory +#include <msg_queue_pydoc.h> + +void bind_msg_queue(py::module& m) +{ + + using msg_queue = ::gr::msg_queue; + + + py::class_<msg_queue, gr::msg_handler, std::shared_ptr<msg_queue>>( + m, "msg_queue", D(msg_queue)) + + .def(py::init(&msg_queue::make), py::arg("limit") = 0, D(msg_queue, make)) + + + .def("handle", &msg_queue::handle, py::arg("msg"), D(msg_queue, handle)) + + + .def("insert_tail", + &msg_queue::insert_tail, + py::arg("msg"), + D(msg_queue, insert_tail)) + + + .def("delete_head", &msg_queue::delete_head, D(msg_queue, delete_head)) + + + .def("delete_head_nowait", + &msg_queue::delete_head_nowait, + D(msg_queue, delete_head_nowait)) + + + .def("flush", &msg_queue::flush, D(msg_queue, flush)) + + + .def("empty_p", &msg_queue::empty_p, D(msg_queue, empty_p)) + + + .def("full_p", &msg_queue::full_p, D(msg_queue, full_p)) + + + .def("count", &msg_queue::count, D(msg_queue, count)) + + + .def("limit", &msg_queue::limit, D(msg_queue, limit)) + + ; + + + py::module m_thread = m.def_submodule("thread"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/nco_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/nco_python.cc new file mode 100644 index 0000000000..46736bd326 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/nco_python.cc @@ -0,0 +1,30 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(nco.h) */ +/* BINDTOOL_HEADER_FILE_HASH(06b2a0c530b7660c0e6d19f503df55f9) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/nco.h> +// pydoc.h is automatically generated in the build directory +#include <nco_pydoc.h> + +void bind_nco(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/prefs_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/prefs_python.cc new file mode 100644 index 0000000000..29a049618d --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/prefs_python.cc @@ -0,0 +1,134 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(prefs.h) */ +/* BINDTOOL_HEADER_FILE_HASH(c461d885bc4fd82aa0301248e9f1e958) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/prefs.h> +// pydoc.h is automatically generated in the build directory +#include <prefs_pydoc.h> + +void bind_prefs(py::module& m) +{ + + using prefs = ::gr::prefs; + + + py::class_<prefs, std::shared_ptr<prefs>>(m, "prefs", D(prefs)) + + .def(py::init<>(), D(prefs, prefs)) + + + .def_static("singleton", &prefs::singleton, D(prefs, singleton)) + + + .def("add_config_file", + &prefs::add_config_file, + py::arg("configfile"), + D(prefs, add_config_file)) + + + .def("to_string", &prefs::to_string, D(prefs, to_string)) + + + .def("save", &prefs::save, D(prefs, save)) + + + .def( + "has_section", &prefs::has_section, py::arg("section"), D(prefs, has_section)) + + + .def("has_option", + &prefs::has_option, + py::arg("section"), + py::arg("option"), + D(prefs, has_option)) + + + .def("get_string", + &prefs::get_string, + py::arg("section"), + py::arg("option"), + py::arg("default_val"), + D(prefs, get_string)) + + + .def("set_string", + &prefs::set_string, + py::arg("section"), + py::arg("option"), + py::arg("val"), + D(prefs, set_string)) + + + .def("get_bool", + &prefs::get_bool, + py::arg("section"), + py::arg("option"), + py::arg("default_val"), + D(prefs, get_bool)) + + + .def("set_bool", + &prefs::set_bool, + py::arg("section"), + py::arg("option"), + py::arg("val"), + D(prefs, set_bool)) + + + .def("get_long", + &prefs::get_long, + py::arg("section"), + py::arg("option"), + py::arg("default_val"), + D(prefs, get_long)) + + + .def("set_long", + &prefs::set_long, + py::arg("section"), + py::arg("option"), + py::arg("val"), + D(prefs, set_long)) + + + .def("get_double", + &prefs::get_double, + py::arg("section"), + py::arg("option"), + py::arg("default_val"), + D(prefs, get_double)) + + + .def("set_double", + &prefs::set_double, + py::arg("section"), + py::arg("option"), + py::arg("val"), + D(prefs, set_double)) + + ; + + + py::module m_thread = m.def_submodule("thread"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/python_bindings.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/python_bindings.cc new file mode 100644 index 0000000000..a178d2ac65 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/python_bindings.cc @@ -0,0 +1,209 @@ + +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include <pybind11/pybind11.h> + +#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION +#include <gnuradio/gr_complex.h> +#include <numpy/arrayobject.h> + +namespace py = pybind11; + +void bind_messages_msg_accepter_msgq(py::module&); +void bind_messages_msg_accepter(py::module&); +void bind_messages_msg_passing(py::module&); +void bind_messages_msg_producer(py::module&); +void bind_messages_msg_queue(py::module&); + +// void bind_attributes(py::module&); +void bind_basic_block(py::module&); +void bind_block(py::module&); +void bind_block_detail(py::module&); +void bind_block_gateway(py::module&); +// void bind_block_registry(py::module&); +void bind_buffer(py::module&); +void bind_constants(py::module&); +void bind_endianness(py::module&); +void bind_expj(py::module&); +void bind_flowgraph(py::module&); +void bind_fxpt(py::module&); +void bind_fxpt_nco(py::module&); +void bind_fxpt_vco(py::module&); +// void bind_gr_complex(py::module&); +void bind_hier_block2(py::module&); +void bind_high_res_timer(py::module&); +void bind_io_signature(py::module&); +void bind_logger(py::module&); +void bind_math(py::module&); +void bind_message(py::module&); +void bind_msg_accepter(py::module&); +// void bind_msg_accepter_msgq(py::module&); +// void bind_msg_passing(py::module&); +// void bind_msg_producer(py::module&); +void bind_msg_queue(py::module&); +// void bind_misc(py::module&);; +void bind_msg_handler(py::module&); +void bind_msg_queue(py::module&); +void bind_nco(py::module&); +void bind_prefs(py::module&); +// void bind_pycallback_object(py::module&); +void bind_random(py::module&); +void bind_realtime(py::module&); +// void bind_realtime_impl(py::module&); +// void bind_rpcbufferedget(py::module&); +// void bind_rpccallbackregister_base(py::module&); +// void bind_rpcmanager(py::module&); +// void bind_rpcmanager_base(py::module&); +// void bind_rpcpmtconverters_thrift(py::module&); +// void bind_rpcregisterhelpers(py::module&); +// void bind_rpcserver_aggregator(py::module&); +// void bind_rpcserver_base(py::module&); +// void bind_rpcserver_booter_aggregator(py::module&); +// void bind_rpcserver_booter_base(py::module&); +// void bind_rpcserver_booter_thrift(py::module&); +// void bind_rpcserver_selector(py::module&); +// void bind_rpcserver_thrift(py::module&); +void bind_runtime_types(py::module&); +void bind_sincos(py::module&); +void bind_sptr_magic(py::module&); +void bind_sync_block(py::module&); +void bind_sync_decimator(py::module&); +void bind_sync_interpolator(py::module&); +void bind_sys_paths(py::module&); +void bind_tag_checker(py::module&); +void bind_tagged_stream_block(py::module&); +void bind_tags(py::module&); +// void bind_thread(py::module&); +// void bind_thread_body_wrapper(py::module&); +// void bind_thread_group(py::module&); +// void bind_thrift_application_base(py::module&); +// void bind_thrift_server_template(py::module&); +void bind_top_block(py::module&); +void bind_tpb_detail(py::module&); +// void bind_types(py::module&); +// void bind_unittests(py::module&); +// void bind_xoroshiro128p(py::module&); + +// We need this hack because import_array() returns NULL +// for newer Python versions. +// This function is also necessary because it ensures access to the C API +// and removes a warning. +void* init_numpy() +{ + import_array(); + return NULL; +} + +PYBIND11_MODULE(gr_python, m) +{ + // Initialize the numpy C API + // (otherwise we will see segmentation faults) + init_numpy(); + + // Allow access to base block methods + py::module::import("pmt"); + + + bind_messages_msg_accepter(m); + bind_messages_msg_queue(m); + bind_messages_msg_accepter_msgq(m); + bind_messages_msg_passing(m); + bind_messages_msg_producer(m); + + + bind_msg_accepter(m); + bind_msg_handler(m); + bind_msg_queue(m); + + bind_io_signature(m); + // // bind_attributes(m); + bind_basic_block(m); + bind_block(m); + bind_block_detail(m); + bind_block_gateway(m); + // // bind_block_registry(m); + bind_buffer(m); + bind_constants(m); + bind_endianness(m); + bind_expj(m); + bind_flowgraph(m); + bind_fxpt(m); + bind_fxpt_nco(m); + bind_fxpt_vco(m); + // // bind_gr_complex(m); + bind_hier_block2(m); + bind_high_res_timer(m); + + bind_logger(m); + bind_math(m); + bind_message(m); + + // // bind_msg_accepter_msgq(m); + // // bind_msg_passing(m); + // // bind_msg_producer(m); + + // // bind_misc(m); + + + bind_nco(m); + bind_prefs(m); + // // bind_pycallback_object(m); + bind_random(m); + bind_realtime(m); + // // bind_realtime_impl(m); + // // bind_rpcbufferedget(m); + // // bind_rpccallbackregister_base(m); + // // bind_rpcmanager(m); + // // bind_rpcmanager_base(m); + // // bind_rpcpmtconverters_thrift(m); + // // bind_rpcregisterhelpers(m); + // // bind_rpcserver_aggregator(m); + // // bind_rpcserver_base(m); + // // bind_rpcserver_booter_aggregator(m); + // // bind_rpcserver_booter_base(m); + // // bind_rpcserver_booter_thrift(m); + // // bind_rpcserver_selector(m); + // // bind_rpcserver_thrift(m); + bind_runtime_types(m); + bind_sincos(m); + bind_sptr_magic(m); + bind_sync_block(m); + bind_sync_decimator(m); + bind_sync_interpolator(m); + bind_sys_paths(m); + bind_tag_checker(m); + bind_tagged_stream_block(m); + bind_tags(m); + // // bind_thread(m); + // // bind_thread_body_wrapper(m); + // // bind_thread_group(m); + // // bind_thrift_application_base(m); + // // bind_thrift_server_template(m); + bind_top_block(m); + bind_tpb_detail(m); + // // bind_types(m); + // // bind_unittests(m); + // // bind_xoroshiro128p(m); + + + // TODO: Move into gr_types.hpp + // %constant int sizeof_char = sizeof(char); + m.attr("sizeof_char") = sizeof(char); + // %constant int sizeof_short = sizeof(short); + m.attr("sizeof_short") = sizeof(short); + // %constant int sizeof_int = sizeof(int); + m.attr("sizeof_int") = sizeof(int); + // %constant int sizeof_float = sizeof(float); + m.attr("sizeof_float") = sizeof(float); + // %constant int sizeof_double = sizeof(double); + m.attr("sizeof_double") = sizeof(double); + // %constant int sizeof_gr_complex = sizeof(gr_complex); + m.attr("sizeof_gr_complex") = sizeof(gr_complex); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/random_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/random_python.cc new file mode 100644 index 0000000000..cc6942bbc9 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/random_python.cc @@ -0,0 +1,77 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(random.h) */ +/* BINDTOOL_HEADER_FILE_HASH(7f6d1465c630113ffe56d12f0e8b65a8) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/random.h> +// pydoc.h is automatically generated in the build directory +#include <random_pydoc.h> + +void bind_random(py::module& m) +{ + + using random = ::gr::random; + + + py::class_<random, std::shared_ptr<random>>(m, "random", D(random)) + + .def(py::init<unsigned int, int, int>(), + py::arg("seed") = 0, + py::arg("min_integer") = 0, + py::arg("max_integer") = 2, + D(random, random, 0)) + .def(py::init<gr::random const&>(), py::arg("arg0"), D(random, random, 1)) + + + .def("reseed", &random::reseed, py::arg("seed"), D(random, reseed)) + + + .def("set_integer_limits", + &random::set_integer_limits, + py::arg("minimum"), + py::arg("maximum"), + D(random, set_integer_limits)) + + + .def("ran_int", &random::ran_int, D(random, ran_int)) + + + .def("ran1", &random::ran1, D(random, ran1)) + + + .def("gasdev", &random::gasdev, D(random, gasdev)) + + + .def("laplacian", &random::laplacian, D(random, laplacian)) + + + .def("rayleigh", &random::rayleigh, D(random, rayleigh)) + + + .def("impulse", &random::impulse, py::arg("factor"), D(random, impulse)) + + + .def("rayleigh_complex", &random::rayleigh_complex, D(random, rayleigh_complex)) + + ; +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/realtime_impl_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/realtime_impl_python.cc new file mode 100644 index 0000000000..792181483d --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/realtime_impl_python.cc @@ -0,0 +1,81 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(realtime_impl.h) */ +/* BINDTOOL_HEADER_FILE_HASH(26d690b565b0b5c7489e5969d697ebf6) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/realtime_impl.h> +// pydoc.h is automatically generated in the build directory +#include <realtime_impl_pydoc.h> + +void bind_realtime_impl(py::module& m) +{ + + + py::enum_<::gr::rt_status_t>(m, "rt_status_t") + .value("RT_OK", ::gr::RT_OK) // 0 + .value("RT_NOT_IMPLEMENTED", ::gr::RT_NOT_IMPLEMENTED) // 1 + .value("RT_NO_PRIVS", ::gr::RT_NO_PRIVS) // 2 + .value("RT_OTHER_ERROR", ::gr::RT_OTHER_ERROR) // 3 + .export_values(); + py::enum_<::gr::rt_sched_policy>(m, "rt_sched_policy") + .value("RT_SCHED_RR", ::gr::RT_SCHED_RR) // 0 + .value("RT_SCHED_FIFO", ::gr::RT_SCHED_FIFO) // 1 + .export_values(); + + + py::module m_impl = m.def_submodule("impl"); + + using rt_sched_param = ::gr::impl::rt_sched_param; + + + py::class_<rt_sched_param, std::shared_ptr<rt_sched_param>>( + m_impl, "rt_sched_param", D(impl, rt_sched_param)) + + .def(py::init<>(), D(impl, rt_sched_param, rt_sched_param, 0)) + .def(py::init<int, gr::rt_sched_policy>(), + py::arg("priority_"), + py::arg("policy_") = ::gr::rt_sched_policy::RT_SCHED_RR, + D(impl, rt_sched_param, rt_sched_param, 1)) + .def(py::init<gr::impl::rt_sched_param const&>(), + py::arg("arg0"), + D(impl, rt_sched_param, rt_sched_param, 2)) + + ; + + + m_impl.def("rt_priority_min", &::gr::impl::rt_priority_min, D(impl, rt_priority_min)); + + + m_impl.def("rt_priority_max", &::gr::impl::rt_priority_max, D(impl, rt_priority_max)); + + + m_impl.def("rt_priority_default", + &::gr::impl::rt_priority_default, + D(impl, rt_priority_default)); + + + m_impl.def("enable_realtime_scheduling", + &::gr::impl::enable_realtime_scheduling, + py::arg("arg0") = gr::impl::rt_sched_param(), + D(impl, enable_realtime_scheduling)); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/realtime_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/realtime_python.cc new file mode 100644 index 0000000000..5efd134281 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/realtime_python.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(realtime.h) */ +/* BINDTOOL_HEADER_FILE_HASH(3a8add4fc688853c32e8c4c8f8e51d0e) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/realtime.h> +// pydoc.h is automatically generated in the build directory +#include <realtime_pydoc.h> + +void bind_realtime(py::module& m) +{ + + + m.def("enable_realtime_scheduling", + &::gr::enable_realtime_scheduling, + D(enable_realtime_scheduling)); + + + py::module m_impl = m.def_submodule("impl"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/rpccallbackregister_base_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/rpccallbackregister_base_python.cc new file mode 100644 index 0000000000..dc20480934 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/rpccallbackregister_base_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(rpccallbackregister_base.h) */ +/* BINDTOOL_HEADER_FILE_HASH(59490b02954c38c1ac4959ee0cd05bd3) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/rpccallbackregister_base.h> + +void bind_rpccallbackregister_base(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/rpcmanager_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcmanager_python.cc new file mode 100644 index 0000000000..c3ba494207 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcmanager_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(rpcmanager.h) */ +/* BINDTOOL_HEADER_FILE_HASH(0bf64e51db052f5a5322be2e472e3cca) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/rpcmanager.h> + +void bind_rpcmanager(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/rpcregisterhelpers_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcregisterhelpers_python.cc new file mode 100644 index 0000000000..8043b048d3 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcregisterhelpers_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(rpcregisterhelpers.h) */ +/* BINDTOOL_HEADER_FILE_HASH(161051f19450588919336b43b4cabc4c) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/rpcregisterhelpers.h> + +void bind_rpcregisterhelpers(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/rpcserver_aggregator_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcserver_aggregator_python.cc new file mode 100644 index 0000000000..b8192873ea --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcserver_aggregator_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(rpcserver_aggregator.h) */ +/* BINDTOOL_HEADER_FILE_HASH(2ffd2a6120b931d25fe874b3adede335) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/rpcserver_aggregator.h> + +void bind_rpcserver_aggregator(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/rpcserver_base_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcserver_base_python.cc new file mode 100644 index 0000000000..f02247e7b4 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcserver_base_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(rpcserver_base.h) */ +/* BINDTOOL_HEADER_FILE_HASH(a90868b635febb56fec31daeffa36498) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/rpcserver_base.h> + +void bind_rpcserver_base(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/rpcserver_booter_aggregator_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcserver_booter_aggregator_python.cc new file mode 100644 index 0000000000..84daa5d8e7 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/rpcserver_booter_aggregator_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(rpcserver_booter_aggregator.h) */ +/* BINDTOOL_HEADER_FILE_HASH(f9a0f4f8fd77eb6045b728cd817aa0a4) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/rpcserver_booter_aggregator.h> + +void bind_rpcserver_booter_aggregator(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/runtime_types_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/runtime_types_python.cc new file mode 100644 index 0000000000..60da3d239b --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/runtime_types_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(runtime_types.h) */ +/* BINDTOOL_HEADER_FILE_HASH(bdd73d157525d81f339b38343434eb8f) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/runtime_types.h> + +void bind_runtime_types(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/sincos_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/sincos_python.cc new file mode 100644 index 0000000000..fb71a14543 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/sincos_python.cc @@ -0,0 +1,48 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(sincos.h) */ +/* BINDTOOL_HEADER_FILE_HASH(799a972b9b6f7739795b7a0eda58e163) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/sincos.h> +// pydoc.h is automatically generated in the build directory +#include <sincos_pydoc.h> + +void bind_sincos(py::module& m) +{ + + + m.def("sincos", + &::gr::sincos, + py::arg("x"), + py::arg("sinx"), + py::arg("cosx"), + D(sincos)); + + + m.def("sincosf", + &::gr::sincosf, + py::arg("x"), + py::arg("sinx"), + py::arg("cosx"), + D(sincosf)); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/sptr_magic_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/sptr_magic_python.cc new file mode 100644 index 0000000000..91706dd079 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/sptr_magic_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(sptr_magic.h) */ +/* BINDTOOL_HEADER_FILE_HASH(53ec33a057706160ccd13788ef91ab9b) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/sptr_magic.h> + +void bind_sptr_magic(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/sync_block_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/sync_block_python.cc new file mode 100644 index 0000000000..884ea84f54 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/sync_block_python.cc @@ -0,0 +1,82 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(sync_block.h) */ +/* BINDTOOL_HEADER_FILE_HASH(a4c0cf64175558267b81683da25f8caa) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/sync_block.h> +// pydoc.h is automatically generated in the build directory +#include <sync_block_pydoc.h> + +void bind_sync_block(py::module& m) +{ + + using sync_block = ::gr::sync_block; + + + py::class_<sync_block, gr::block, gr::basic_block, std::shared_ptr<sync_block>>( + m, "sync_block", D(sync_block)) + + + .def("work", + &sync_block::work, + py::arg("noutput_items"), + py::arg("input_items"), + py::arg("output_items"), + D(sync_block, work)) + + + .def("forecast", + &sync_block::forecast, + py::arg("noutput_items"), + py::arg("ninput_items_required"), + D(sync_block, forecast)) + + + .def("general_work", + &sync_block::general_work, + py::arg("noutput_items"), + py::arg("ninput_items"), + py::arg("input_items"), + py::arg("output_items"), + D(sync_block, general_work)) + + + .def("fixed_rate_ninput_to_noutput", + &sync_block::fixed_rate_ninput_to_noutput, + py::arg("ninput"), + D(sync_block, fixed_rate_ninput_to_noutput)) + + + .def("fixed_rate_noutput_to_ninput", + &sync_block::fixed_rate_noutput_to_ninput, + py::arg("noutput"), + D(sync_block, fixed_rate_noutput_to_ninput)) + + ; + + + py::module m_messages = m.def_submodule("messages"); + + + py::module m_thread = m.def_submodule("thread"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/sync_decimator_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/sync_decimator_python.cc new file mode 100644 index 0000000000..48030fdf1a --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/sync_decimator_python.cc @@ -0,0 +1,86 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(sync_decimator.h) */ +/* BINDTOOL_HEADER_FILE_HASH(b6dc9db79f929ad2a09fbd28c6ee3f9a) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/sync_decimator.h> +// pydoc.h is automatically generated in the build directory +#include <sync_decimator_pydoc.h> + +void bind_sync_decimator(py::module& m) +{ + + using sync_decimator = ::gr::sync_decimator; + + + py::class_<sync_decimator, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<sync_decimator>>(m, "sync_decimator", D(sync_decimator)) + + + .def("decimation", &sync_decimator::decimation, D(sync_decimator, decimation)) + + + .def("set_decimation", + &sync_decimator::set_decimation, + py::arg("decimation"), + D(sync_decimator, set_decimation)) + + + .def("forecast", + &sync_decimator::forecast, + py::arg("noutput_items"), + py::arg("ninput_items_required"), + D(sync_decimator, forecast)) + + + .def("general_work", + &sync_decimator::general_work, + py::arg("noutput_items"), + py::arg("ninput_items"), + py::arg("input_items"), + py::arg("output_items"), + D(sync_decimator, general_work)) + + + .def("fixed_rate_ninput_to_noutput", + &sync_decimator::fixed_rate_ninput_to_noutput, + py::arg("ninput"), + D(sync_decimator, fixed_rate_ninput_to_noutput)) + + + .def("fixed_rate_noutput_to_ninput", + &sync_decimator::fixed_rate_noutput_to_ninput, + py::arg("noutput"), + D(sync_decimator, fixed_rate_noutput_to_ninput)) + + ; + + + py::module m_messages = m.def_submodule("messages"); + + + py::module m_thread = m.def_submodule("thread"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/sync_interpolator_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/sync_interpolator_python.cc new file mode 100644 index 0000000000..fd76c632e4 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/sync_interpolator_python.cc @@ -0,0 +1,89 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(sync_interpolator.h) */ +/* BINDTOOL_HEADER_FILE_HASH(8a002a4a14c8cc88411bf3b4b0234e7a) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/sync_interpolator.h> +// pydoc.h is automatically generated in the build directory +#include <sync_interpolator_pydoc.h> + +void bind_sync_interpolator(py::module& m) +{ + + using sync_interpolator = ::gr::sync_interpolator; + + + py::class_<sync_interpolator, + gr::sync_block, + gr::block, + gr::basic_block, + std::shared_ptr<sync_interpolator>>( + m, "sync_interpolator", D(sync_interpolator)) + + + .def("interpolation", + &sync_interpolator::interpolation, + D(sync_interpolator, interpolation)) + + + .def("set_interpolation", + &sync_interpolator::set_interpolation, + py::arg("interpolation"), + D(sync_interpolator, set_interpolation)) + + + .def("forecast", + &sync_interpolator::forecast, + py::arg("noutput_items"), + py::arg("ninput_items_required"), + D(sync_interpolator, forecast)) + + + .def("general_work", + &sync_interpolator::general_work, + py::arg("noutput_items"), + py::arg("ninput_items"), + py::arg("input_items"), + py::arg("output_items"), + D(sync_interpolator, general_work)) + + + .def("fixed_rate_ninput_to_noutput", + &sync_interpolator::fixed_rate_ninput_to_noutput, + py::arg("ninput"), + D(sync_interpolator, fixed_rate_ninput_to_noutput)) + + + .def("fixed_rate_noutput_to_ninput", + &sync_interpolator::fixed_rate_noutput_to_ninput, + py::arg("noutput"), + D(sync_interpolator, fixed_rate_noutput_to_ninput)) + + ; + + + py::module m_messages = m.def_submodule("messages"); + + + py::module m_thread = m.def_submodule("thread"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/sys_paths_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/sys_paths_python.cc new file mode 100644 index 0000000000..f7c410c3c1 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/sys_paths_python.cc @@ -0,0 +1,41 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(sys_paths.h) */ +/* BINDTOOL_HEADER_FILE_HASH(d612f4abb40047c64395b4177ff3ae1f) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/sys_paths.h> +// pydoc.h is automatically generated in the build directory +#include <sys_paths_pydoc.h> + +void bind_sys_paths(py::module& m) +{ + + + m.def("tmp_path", &::gr::tmp_path, D(tmp_path)); + + + m.def("appdata_path", &::gr::appdata_path, D(appdata_path)); + + + m.def("userconf_path", &::gr::userconf_path, D(userconf_path)); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/tag_checker_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/tag_checker_python.cc new file mode 100644 index 0000000000..cfe40c6a1b --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/tag_checker_python.cc @@ -0,0 +1,57 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(tag_checker.h) */ +/* BINDTOOL_HEADER_FILE_HASH(4f4bad08f4f039dbd5150a36e29d365c) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/tag_checker.h> +// pydoc.h is automatically generated in the build directory +#include <tag_checker_pydoc.h> + +void bind_tag_checker(py::module& m) +{ + + using tag_checker = ::gr::tag_checker; + + + py::class_<tag_checker, std::shared_ptr<tag_checker>>( + m, "tag_checker", D(tag_checker)) + + .def(py::init<std::vector<gr::tag_t, std::allocator<gr::tag_t>>&>(), + py::arg("tags"), + D(tag_checker, tag_checker, 0)) + .def(py::init<gr::tag_checker const&>(), + py::arg("arg0"), + D(tag_checker, tag_checker, 1)) + + + .def("get_tags", + &tag_checker::get_tags, + py::arg("tag_list"), + py::arg("offset"), + D(tag_checker, get_tags)) + + ; + + + py::module m_messages = m.def_submodule("messages"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/tagged_stream_block_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/tagged_stream_block_python.cc new file mode 100644 index 0000000000..369ac8ba32 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/tagged_stream_block_python.cc @@ -0,0 +1,81 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(tagged_stream_block.h) */ +/* BINDTOOL_HEADER_FILE_HASH(03f4139c3fd58d7c80fde38da58ef670) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/tagged_stream_block.h> +// pydoc.h is automatically generated in the build directory +#include <tagged_stream_block_pydoc.h> + +void bind_tagged_stream_block(py::module& m) +{ + + using tagged_stream_block = ::gr::tagged_stream_block; + + + py::class_<tagged_stream_block, + gr::block, + gr::basic_block, + std::shared_ptr<tagged_stream_block>>( + m, "tagged_stream_block", D(tagged_stream_block)) + + + .def("forecast", + &tagged_stream_block::forecast, + py::arg("noutput_items"), + py::arg("ninput_items_required"), + D(tagged_stream_block, forecast)) + + + .def("check_topology", + &tagged_stream_block::check_topology, + py::arg("ninputs"), + py::arg("arg1"), + D(tagged_stream_block, check_topology)) + + + .def("general_work", + &tagged_stream_block::general_work, + py::arg("noutput_items"), + py::arg("ninput_items"), + py::arg("input_items"), + py::arg("output_items"), + D(tagged_stream_block, general_work)) + + + .def("work", + &tagged_stream_block::work, + py::arg("noutput_items"), + py::arg("ninput_items"), + py::arg("input_items"), + py::arg("output_items"), + D(tagged_stream_block, work)) + + ; + + + py::module m_messages = m.def_submodule("messages"); + + + py::module m_thread = m.def_submodule("thread"); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/tags_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/tags_python.cc new file mode 100644 index 0000000000..2487be0100 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/tags_python.cc @@ -0,0 +1,55 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(tags.h) */ +/* BINDTOOL_HEADER_FILE_HASH(73eb73e445943e224cdbae24b0b0ab76) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/tags.h> +// pydoc.h is automatically generated in the build directory +#include <tags_pydoc.h> + +void bind_tags(py::module& m) +{ + + using tag_t = ::gr::tag_t; + + + py::class_<tag_t, std::shared_ptr<tag_t>>(m, "tag_t", D(tag_t)) + + .def(py::init<>(), D(tag_t, tag_t, 0)) + .def(py::init<gr::tag_t const&>(), py::arg("rhs"), D(tag_t, tag_t, 1)) + + .def_static("offset_compare", + &tag_t::offset_compare, + py::arg("x"), + py::arg("y"), + D(tag_t, offset_compare)) + + .def_readwrite("offset", &tag_t::offset) + .def_readwrite("key", &tag_t::key) + .def_readwrite("value", &tag_t::value) + .def_readwrite("srcid", &tag_t::srcid) + .def_readwrite("marked_deleted", &tag_t::marked_deleted) + + // TODO - put in operators + ; +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/thread/thread_body_wrapper_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/thread/thread_body_wrapper_python.cc new file mode 100644 index 0000000000..b062a0d303 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/thread/thread_body_wrapper_python.cc @@ -0,0 +1,20 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/thread_body_wrapper.h> + +void bind_thread_body_wrapper(py::module& m) { m.def("mask_signals", &gr::mask_signals); } diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/thread/thread_group_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/thread/thread_group_python.cc new file mode 100644 index 0000000000..66666898a3 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/thread/thread_group_python.cc @@ -0,0 +1,37 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/thread_group.h> + +void bind_thread_group(py::module& m) +{ + using thread_group = gr::thread_group; + + + py::class_<thread_group, + boost::noncopyable_::noncopyable, + std::shared_ptr<thread_group>>(m, "thread_group") + + .def(py::init<>()) + + .def("create_thread", &thread_group::create_thread, py::arg("threadfunc")) + .def("add_thread", &thread_group::add_thread, py::arg("thrd")) + .def("remove_thread", &thread_group::remove_thread, py::arg("thrd")) + .def("join_all", &thread_group::join_all) + .def("interrupt_all", &thread_group::interrupt_all) + .def("size", &thread_group::size); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/thread/thread_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/thread/thread_python.cc new file mode 100644 index 0000000000..87e769ef88 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/thread/thread_python.cc @@ -0,0 +1,53 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/thread.h> + +void bind_thread(py::module& m) +{ + + + m.def("get_current_thread_id", &gr::get_current_thread_id); + m.def("thread_bind_to_processor", + (void (*)(std::vector<int, std::allocator<int>> const&)) & + gr::thread_bind_to_processor, + py::arg("mask")); + m.def("thread_bind_to_processor", + (void (*)(int)) & gr::thread_bind_to_processor, + py::arg("n")); + m.def("thread_bind_to_processor", + (void (*)(gr::thread::gr_thread_t, + std::vector<int, std::allocator<int>> const&)) & + gr::thread_bind_to_processor, + py::arg("thread"), + py::arg("mask")); + m.def("thread_bind_to_processor", + (void (*)(gr::thread::gr_thread_t, unsigned int)) & + gr::thread_bind_to_processor, + py::arg("thread"), + py::arg("n")); + m.def("thread_unbind", (void (*)()) & gr::thread_unbind); + m.def("thread_unbind", + (void (*)(gr::thread::gr_thread_t)) & gr::thread_unbind, + py::arg("thread")); + m.def("thread_priority", &gr::thread_priority, py::arg("thread")); + m.def("set_thread_priority", + &gr::set_thread_priority, + py::arg("thread"), + py::arg("priority")); + m.def("set_thread_name", &gr::set_thread_name, py::arg("thread"), py::arg("name")); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/thrift_application_base_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/thrift_application_base_python.cc new file mode 100644 index 0000000000..b7e5fa0f23 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/thrift_application_base_python.cc @@ -0,0 +1,28 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(thrift_application_base.h) */ +/* BINDTOOL_HEADER_FILE_HASH(6308813ad7a4fccf1d2baa9ab79a8634) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/thrift_application_base.h> + +void bind_thrift_application_base(py::module& m) {} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/top_block_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/top_block_python.cc new file mode 100644 index 0000000000..16a9c817a8 --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/top_block_python.cc @@ -0,0 +1,154 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(top_block.h) */ +/* BINDTOOL_HEADER_FILE_HASH(c3f0d1bdb473739fbd3e929fc8338e94) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/runtime_types.h> +#include <gnuradio/top_block.h> +// pydoc.h is automatically generated in the build directory +#include <top_block_pydoc.h> + +#define GR_PYTHON_BLOCKING_CODE(code) \ + { \ + PyThreadState* _save; \ + _save = PyEval_SaveThread(); \ + try { \ + code \ + } catch (...) { \ + PyEval_RestoreThread(_save); \ + throw; \ + } \ + PyEval_RestoreThread(_save); \ + } + + +void top_block_run_unlocked(gr::top_block_sptr r) noexcept(false) +{ + GR_PYTHON_BLOCKING_CODE(r->run();) +} + +void top_block_start_unlocked(gr::top_block_sptr r, int max_noutput_items) noexcept(false) +{ + GR_PYTHON_BLOCKING_CODE(r->start(max_noutput_items);) +} + +void top_block_wait_unlocked(gr::top_block_sptr r) noexcept(false) +{ + GR_PYTHON_BLOCKING_CODE(r->wait();) +} + +void top_block_stop_unlocked(gr::top_block_sptr r) noexcept(false) +{ + GR_PYTHON_BLOCKING_CODE(r->stop();) +} + +void top_block_unlock_unlocked(gr::top_block_sptr r) noexcept(false) +{ + GR_PYTHON_BLOCKING_CODE(r->unlock();) +} + + +void bind_top_block(py::module& m) +{ + using top_block = gr::top_block; + + + py::class_<top_block, gr::hier_block2, gr::basic_block, std::shared_ptr<top_block>>( + m, "top_block_pb", D(top_block)) + + + .def(py::init(&gr::make_top_block), + py::arg("name"), + py::arg("catch_exceptions") = false) + + .def("run", + &top_block::run, + py::arg("max_noutput_items") = 100000000, + D(top_block, run)) + + + .def("start", + &top_block::start, + py::arg("max_noutput_items") = 100000000, + D(top_block, start)) + + + .def("stop", &top_block::stop, D(top_block, stop)) + + + .def("wait", &top_block::wait, D(top_block, wait)) + + + .def("lock", &top_block::lock, D(top_block, lock)) + + + .def("unlock", &top_block::unlock, D(top_block, unlock)) + + + .def("edge_list", &top_block::edge_list, D(top_block, edge_list)) + + + .def("msg_edge_list", &top_block::msg_edge_list, D(top_block, msg_edge_list)) + + + .def("dump", &top_block::dump, D(top_block, dump)) + + + .def("max_noutput_items", + &top_block::max_noutput_items, + D(top_block, max_noutput_items)) + + + .def("set_max_noutput_items", + &top_block::set_max_noutput_items, + py::arg("nmax"), + D(top_block, set_max_noutput_items)) + + + .def("to_top_block", &top_block::to_top_block, D(top_block, to_top_block)) + + + .def("setup_rpc", &top_block::setup_rpc, D(top_block, setup_rpc)) + + ; + + + m.def("make_top_block", + &::gr::make_top_block, + py::arg("name"), + py::arg("catch_exceptions") = true, + D(make_top_block)); + + + m.def("cast_to_top_block_sptr", + &::gr::cast_to_top_block_sptr, + py::arg("block"), + D(cast_to_top_block_sptr)); + + + m.def("top_block_run_unlocked", &top_block_run_unlocked); + m.def("top_block_start_unlocked", &top_block_start_unlocked); + m.def("top_block_wait_unlocked", &top_block_wait_unlocked); + m.def("top_block_stop_unlocked", &top_block_stop_unlocked); + m.def("top_block_unlock_unlocked", &top_block_unlock_unlocked); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/bindings/tpb_detail_python.cc b/gnuradio-runtime/python/gnuradio/gr/bindings/tpb_detail_python.cc new file mode 100644 index 0000000000..0e7a90aedd --- /dev/null +++ b/gnuradio-runtime/python/gnuradio/gr/bindings/tpb_detail_python.cc @@ -0,0 +1,56 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/***********************************************************************************/ +/* This file is automatically generated using bindtool and can be manually edited */ +/* The following lines can be configured to regenerate this file during cmake */ +/* If manual edits are made, the following tags should be modified accordingly. */ +/* BINDTOOL_GEN_AUTOMATIC(0) */ +/* BINDTOOL_USE_PYGCCXML(0) */ +/* BINDTOOL_HEADER_FILE(tpb_detail.h) */ +/* BINDTOOL_HEADER_FILE_HASH(e08c6f246b04f1719d3377c5e3992f53) */ +/***********************************************************************************/ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <gnuradio/block_detail.h> +#include <gnuradio/tpb_detail.h> +// pydoc.h is automatically generated in the build directory +#include <tpb_detail_pydoc.h> + +void bind_tpb_detail(py::module& m) +{ + + using tpb_detail = ::gr::tpb_detail; + + + py::class_<tpb_detail, std::shared_ptr<tpb_detail>>(m, "tpb_detail", D(tpb_detail)) + + .def(py::init<>(), D(tpb_detail, tpb_detail)) + + + .def("notify_upstream", + &tpb_detail::notify_upstream, + py::arg("d"), + D(tpb_detail, notify_upstream)) + .def("notify_downstream", + &tpb_detail::notify_downstream, + py::arg("d"), + D(tpb_detail, notify_downstream)) + .def("notify_neighbors", + &tpb_detail::notify_neighbors, + py::arg("d"), + D(tpb_detail, notify_neighbors)) + .def("notify_msg", &tpb_detail::notify_msg) + .def("clear_changed", &tpb_detail::clear_changed); +} diff --git a/gnuradio-runtime/python/gnuradio/gr/gateway.py b/gnuradio-runtime/python/gnuradio/gr/gateway.py index 71d15781d2..615027b833 100644 --- a/gnuradio-runtime/python/gnuradio/gr/gateway.py +++ b/gnuradio-runtime/python/gnuradio/gr/gateway.py @@ -1,5 +1,5 @@ # -# Copyright 2011-2012, 2018 Free Software Foundation, Inc. +# Copyright 2011-2012, 2018, 2020 Free Software Foundation, Inc. # # This file is part of GNU Radio # @@ -12,11 +12,12 @@ from __future__ import unicode_literals import numpy +import ctypes + +from . import gr_python as gr +from .gr_python import io_signature # , io_signaturev +from .gr_python import block_gateway -from . import runtime_swig as gr -from .runtime_swig import io_signature, io_signaturev -from .runtime_swig import block_gw_message_type -from .runtime_swig import block_gateway ######################################################################## # Magic to turn pointers into numpy arrays @@ -25,54 +26,20 @@ from .runtime_swig import block_gateway def pointer_to_ndarray(addr, dtype, nitems): class array_like(object): __array_interface__ = { - 'data' : (int(addr), False), - 'typestr' : dtype.base.str, - 'descr' : dtype.base.descr, - 'shape' : (nitems,) + dtype.shape, - 'strides' : None, - 'version' : 3 + 'data': (int(addr), False), + 'typestr': dtype.base.str, + 'descr': dtype.base.descr, + 'shape': (nitems,) + dtype.shape, + 'strides': None, + 'version': 3 } return numpy.asarray(array_like()).view(dtype.base) ######################################################################## -# Handler that does callbacks from C++ -######################################################################## -class gateway_handler(gr.feval_ll): - - #don't put a constructor, it won't work - - def init(self, callback): - self._callback = callback - - def eval(self, arg): - try: self._callback() - except Exception as ex: - print("handler caught exception: %s"%ex) - import traceback; traceback.print_exc() - raise ex - return 0 - -######################################################################## -# Handler that does callbacks from C++ +# io_signature for Python ######################################################################## -class msg_handler(gr.feval_p): - - #don't put a constructor, it won't work - - def init(self, callback): - self._callback = callback - def eval(self, arg): - try: self._callback(arg) - except Exception as ex: - print("handler caught exception: %s"%ex) - import traceback; traceback.print_exc() - raise ex - return 0 -######################################################################## -# io_signature for Python -######################################################################## class py_io_signature(object): """ Describes the type/number of ports for block input or output. @@ -94,15 +61,15 @@ class py_io_signature(object): """ self.__min_ports = min_ports self.__max_ports = max_ports - self.__types = tuple( numpy.dtype(t) for t in type_list ) + self.__types = tuple(numpy.dtype(t) for t in type_list) def gr_io_signature(self): """ Make/return a gr.io_signature. A non-empty list of sizes is required, even if there are no ports. """ - return io_signaturev(self.__min_ports, self.__max_ports, - [t.itemsize for t in self.__types] or [0]) + return io_signature.makev(self.__min_ports, self.__max_ports, + [t.itemsize for t in self.__types] or [0]) def port_types(self, nports): """ @@ -129,14 +96,19 @@ class py_io_signature(object): ######################################################################## # The guts that make this into a gr block ######################################################################## + + class gateway_block(object): - def __init__(self, name, in_sig, out_sig, work_type, factor): + def __init__(self, name, in_sig, out_sig, block_type): + self._decim = 1 + self._interp = 1 + self._block_type = block_type # Normalize the many Python ways of saying 'nothing' to '()' in_sig = in_sig or () out_sig = out_sig or () - + # Backward compatibility: array of type strings -> py_io_signature if type(in_sig) is py_io_signature: self.__in_sig = in_sig @@ -145,98 +117,93 @@ class gateway_block(object): if type(out_sig) is py_io_signature: self.__out_sig = out_sig else: - self.__out_sig = py_io_signature(len(out_sig), len(out_sig), out_sig) - - #create internal gateway block - self.__handler = gateway_handler() - self.__handler.init(self.__gr_block_handle) - self.__gateway = block_gateway( - self.__handler, name, - self.__in_sig.gr_io_signature(), self.__out_sig.gr_io_signature(), - work_type, factor) - self.__message = self.__gateway.block_message() - - #dict to keep references to all message handlers - self.__msg_handlers = {} - - #register block functions - prefix = 'block__' - for attr in [x for x in dir(self.__gateway) if x.startswith(prefix)]: - setattr(self, attr.replace(prefix, ''), getattr(self.__gateway, attr)) - self.pop_msg_queue = lambda: gr.block_gw_pop_msg_queue_safe(self.__gateway) + self.__out_sig = py_io_signature( + len(out_sig), len(out_sig), out_sig) + + self.gateway = block_gateway( + self, name, self.__in_sig.gr_io_signature(), self.__out_sig.gr_io_signature()) + + self.msg_handlers = {} + + def __getattr__(self, name): + """ + Pass-through member requests to the C++ object. + """ + if not hasattr(self, "gateway"): + raise RuntimeError( + "{0}: invalid state -- did you forget to call {0}.__init__ in " + "a derived class?".format(self.__class__.__name__)) + return getattr(self.gateway, name) def to_basic_block(self): """ Makes this block connectable by hier/top block python """ - return self.__gateway.to_basic_block() + return self.gateway.to_basic_block() + + def fixed_rate_noutput_to_ninput(self, noutput_items): + return int((noutput_items * self._decim / self._interp) + self.gateway.history() - 1) - def __gr_block_handle(self): + def handle_forecast(self, noutput_items, ninputs): """ - Dispatch tasks according to the action type specified in the message. + This is the handler function for forecast calls from + block_gateway in c++ across pybind11 wrappers """ + return self.forecast(noutput_items, ninputs) + + # return ninput_items_required - if self.__message.action == gr.block_gw_message_type.ACTION_GENERAL_WORK: - # Actual number of inputs/output from scheduler - ninputs = len(self.__message.general_work_args_input_items) - noutputs = len(self.__message.general_work_args_output_items) - in_types = self.__in_sig.port_types(ninputs) - out_types = self.__out_sig.port_types(noutputs) - self.__message.general_work_args_return_value = self.general_work( - - input_items=[pointer_to_ndarray( - self.__message.general_work_args_input_items[i], - in_types[i], - self.__message.general_work_args_ninput_items[i] - ) for i in range(ninputs)], - - output_items=[pointer_to_ndarray( - self.__message.general_work_args_output_items[i], - out_types[i], - self.__message.general_work_args_noutput_items - ) for i in range(noutputs)], - ) - - elif self.__message.action == gr.block_gw_message_type.ACTION_WORK: - # Actual number of inputs/output from scheduler - ninputs = len(self.__message.work_args_input_items) - noutputs = len(self.__message.work_args_output_items) - in_types = self.__in_sig.port_types(ninputs) - out_types = self.__out_sig.port_types(noutputs) - self.__message.work_args_return_value = self.work( - - input_items=[pointer_to_ndarray( - self.__message.work_args_input_items[i], - in_types[i], - self.__message.work_args_ninput_items - ) for i in range(ninputs)], - - output_items=[pointer_to_ndarray( - self.__message.work_args_output_items[i], - out_types[i], - self.__message.work_args_noutput_items - ) for i in range(noutputs)], - ) - - elif self.__message.action == gr.block_gw_message_type.ACTION_FORECAST: - self.forecast( - noutput_items=self.__message.forecast_args_noutput_items, - ninput_items_required=self.__message.forecast_args_ninput_items_required, - ) - - elif self.__message.action == gr.block_gw_message_type.ACTION_START: - self.__message.start_args_return_value = self.start() - - elif self.__message.action == gr.block_gw_message_type.ACTION_STOP: - self.__message.stop_args_return_value = self.stop() - - def forecast(self, noutput_items, ninput_items_required): + def forecast(self, noutput_items, ninputs): """ forecast is only called from a general block this is the default implementation """ - for i in range(len(ninput_items_required)): - ninput_items_required[i] = noutput_items + self.history() - 1 + ninput_items_required = [0]*ninputs + for i in range(ninputs): + ninput_items_required[i] = noutput_items + self.gateway.history() - 1 + + return ninput_items_required + + def handle_general_work(self, noutput_items, + ninput_items, + input_items, + output_items): + + ninputs = len(input_items) + noutputs = len(output_items) + in_types = self.in_sig().port_types(ninputs) + out_types = self.out_sig().port_types(noutputs) + + + ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p + ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p] + + if self._block_type != gr.GW_BLOCK_GENERAL: + ii=[pointer_to_ndarray( + ctypes.pythonapi.PyCapsule_GetPointer(input_items[i],None), + in_types[i], + self.fixed_rate_noutput_to_ninput(noutput_items) + ) for i in range(ninputs)] + else: + ii=[pointer_to_ndarray( + ctypes.pythonapi.PyCapsule_GetPointer(input_items[i],None), + in_types[i], + ninput_items[i] + ) for i in range(ninputs)] + + oo=[pointer_to_ndarray( + ctypes.pythonapi.PyCapsule_GetPointer(output_items[i],None), + out_types[i], + noutput_items + ) for i in range(noutputs)] + + if self._block_type != gr.GW_BLOCK_GENERAL: + r = self.work(ii,oo) + self.consume_items(r) + else: + r = self.general_work(ii,oo) + + return r def general_work(self, *args, **kwargs): """general work to be overloaded in a derived class""" @@ -252,25 +219,43 @@ class gateway_block(object): def stop(self): return True - def set_msg_handler(self, which_port, handler_func): - handler = msg_handler() - handler.init(handler_func) - self.__gateway.set_msg_handler_feval(which_port, handler) - # Save handler object in class so it's not garbage collected - self.__msg_handlers[which_port] = handler - def in_sig(self): return self.__in_sig def out_sig(self): return self.__out_sig + def set_msg_handler(self, which_port, handler_function): + self.gateway.set_msg_handler_pybind(which_port, handler_function.__name__) + # Save handler object in class so it's not garbage collected + self.msg_handlers[which_port] = handler_function + + # TODO: Make gateway_block have an is-a instead of has-a relationship + # That way we don't have to wrap all these functions + + # def message_port_register_in(self, port_id): + # return self.gateway.message_port_register_in(port_id) + + # def message_port_register_out(self, port_id): + # return self.gateway.message_port_register_out(port_id) + + # def consume_each(self, how_many_items): + # return self.gateway.consume_each( how_many_items) + + # def consume(self, which_input, how_many_items): + # return self.gateway.consume(which_input, how_many_items) + + # def produce(self, which_output, how_many_items): + # return self.gateway.produce(which_output, how_many_items) + + ######################################################################## # Wrappers for the user to inherit from ######################################################################## -class basic_block(gateway_block): - """Args: +class basic_block(gateway_block): + """ + Args: name (str): block name in_sig (gr.py_io_signature): input port signature @@ -279,18 +264,19 @@ class basic_block(gateway_block): For backward compatibility, a sequence of numpy type names is also accepted as an io signature. - """ def __init__(self, name, in_sig, out_sig): gateway_block.__init__(self, - name=name, - in_sig=in_sig, - out_sig=out_sig, - work_type=gr.GR_BLOCK_GW_WORK_GENERAL, - factor=1, #not relevant factor - ) - -class sync_block(gateway_block): + name=name, + in_sig=in_sig, + out_sig=out_sig, + block_type=gr.GW_BLOCK_GENERAL + ) + + def consume_items(self, nitems ): + pass + +class sync_block(gateway_block): """ Args: name (str): block name @@ -304,12 +290,18 @@ class sync_block(gateway_block): """ def __init__(self, name, in_sig, out_sig): gateway_block.__init__(self, - name=name, - in_sig=in_sig, - out_sig=out_sig, - work_type=gr.GR_BLOCK_GW_WORK_SYNC, - factor=1, - ) + name=name, + in_sig=in_sig, + out_sig=out_sig, + block_type=gr.GW_BLOCK_SYNC + ) + self._decim = 1 + self._interp = 1 + + def consume_items(self, nitems ): + if (nitems > 0): + self.gateway.consume_each(nitems) + class decim_block(gateway_block): """ @@ -325,12 +317,24 @@ class decim_block(gateway_block): """ def __init__(self, name, in_sig, out_sig, decim): gateway_block.__init__(self, - name=name, - in_sig=in_sig, - out_sig=out_sig, - work_type=gr.GR_BLOCK_GW_WORK_DECIM, - factor=decim, - ) + name=name, + in_sig=in_sig, + out_sig=out_sig, + block_type=gr.GW_BLOCK_DECIM + ) + self._decim = decim + self._interp = 1 + self.gateway.set_relative_rate(self._interp, self._decim) + self.gateway.set_output_multiple(self._interp) + + def consume_items(self, nitems ): + if (nitems > 0): + self.gateway.consume_each(int(nitems * self._decim)) + + def forecast(self, noutput_items, ninputs): + return [self.fixed_rate_noutput_to_ninput(noutput_items) for ii in range(ninputs)] + + class interp_block(gateway_block): """ @@ -346,9 +350,22 @@ class interp_block(gateway_block): """ def __init__(self, name, in_sig, out_sig, interp): gateway_block.__init__(self, - name=name, - in_sig=in_sig, - out_sig=out_sig, - work_type=gr.GR_BLOCK_GW_WORK_INTERP, - factor=interp, - ) + name=name, + in_sig=in_sig, + out_sig=out_sig, + block_type=gr.GW_BLOCK_DECIM + ) + self._decim = 1 + self._interp = interp + self.gateway.set_relative_rate(self._interp, self._decim) + self.gateway.set_output_multiple(self._interp) + + + def consume_items(self, nitems ): + if (nitems > 0): + self.gateway.consume_each(int(nitems / self._interp)) + + def forecast(self, noutput_items, ninputs): + # print("{},{},{}".format(noutput_items, ninputs, [self.fixed_rate_noutput_to_ninput(noutput_items) for ii in range(ninputs)])) + + return [self.fixed_rate_noutput_to_ninput(noutput_items) for ii in range(ninputs)] diff --git a/gnuradio-runtime/python/gnuradio/gr/hier_block2.py b/gnuradio-runtime/python/gnuradio/gr/hier_block2.py index 60b7fdb5ac..ead607ba8a 100644 --- a/gnuradio-runtime/python/gnuradio/gr/hier_block2.py +++ b/gnuradio-runtime/python/gnuradio/gr/hier_block2.py @@ -10,7 +10,9 @@ from __future__ import unicode_literals import functools -from .runtime_swig import hier_block2_swig, dot_graph +# from .runtime_swig import hier_block2_swig, dot_graph +from .gr_python import hier_block2_pb + import pmt @@ -68,7 +70,7 @@ class hier_block2(object): """ Create a hierarchical block with a given name and I/O signatures. """ - self._impl = hier_block2_swig(name, input_signature, output_signature) + self._impl = hier_block2_pb(name, input_signature, output_signature) def __getattr__(self, name): """ @@ -140,8 +142,8 @@ class hier_block2(object): """ self.primitive_message_port_register_hier_out(pmt.intern(portname)) - def dot_graph(self): - """ - Return graph representation in dot language - """ - return dot_graph(self._impl) + # def dot_graph(self): + # """ + # Return graph representation in dot language + # """ + # return dot_graph(self._impl) diff --git a/gnuradio-runtime/python/gnuradio/gr/qa_feval.py b/gnuradio-runtime/python/gnuradio/gr/qa_feval.py deleted file mode 100644 index 7018fd9f1a..0000000000 --- a/gnuradio-runtime/python/gnuradio/gr/qa_feval.py +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2006,2007,2010 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# SPDX-License-Identifier: GPL-3.0-or-later -# -# - - -from gnuradio import gr, gr_unittest - -class my_add2_dd(gr.feval_dd): - def eval(self, x): - return x + 2 - -class my_add2_ll(gr.feval_ll): - def eval(self, x): - return x + 2 - -class my_add2_cc(gr.feval_cc): - def eval(self, x): - return x + (2 - 2j) - -class my_feval(gr.feval): - def __init__(self): - gr.feval.__init__(self) - self.fired = False - def eval(self): - self.fired = True - -class test_feval(gr_unittest.TestCase): - - def test_dd_1(self): - f = my_add2_dd() - src_data = (0.0, 1.0, 2.0, 3.0, 4.0) - expected_result = (2.0, 3.0, 4.0, 5.0, 6.0) - # this is all in python... - actual_result = tuple([f.eval(x) for x in src_data]) - self.assertEqual(expected_result, actual_result) - - def test_dd_2(self): - f = my_add2_dd() - src_data = (0.0, 1.0, 2.0, 3.0, 4.0) - expected_result = (2.0, 3.0, 4.0, 5.0, 6.0) - # this is python -> C++ -> python and back again... - actual_result = tuple([gr.feval_dd_example(f, x) for x in src_data]) - self.assertEqual(expected_result, actual_result) - - - def test_ll_1(self): - f = my_add2_ll() - src_data = (0, 1, 2, 3, 4) - expected_result = (2, 3, 4, 5, 6) - # this is all in python... - actual_result = tuple([f.eval(x) for x in src_data]) - self.assertEqual(expected_result, actual_result) - - def test_ll_2(self): - f = my_add2_ll() - src_data = (0, 1, 2, 3, 4) - expected_result = (2, 3, 4, 5, 6) - # this is python -> C++ -> python and back again... - actual_result = tuple([gr.feval_ll_example(f, x) for x in src_data]) - self.assertEqual(expected_result, actual_result) - - - def test_cc_1(self): - f = my_add2_cc() - src_data = (0+1j, 2+3j, 4+5j, 6+7j) - expected_result = (2-1j, 4+1j, 6+3j, 8+5j) - # this is all in python... - actual_result = tuple([f.eval(x) for x in src_data]) - self.assertEqual(expected_result, actual_result) - - def test_cc_2(self): - f = my_add2_cc() - src_data = (0+1j, 2+3j, 4+5j, 6+7j) - expected_result = (2-1j, 4+1j, 6+3j, 8+5j) - # this is python -> C++ -> python and back again... - actual_result = tuple([gr.feval_cc_example(f, x) for x in src_data]) - self.assertEqual(expected_result, actual_result) - - def test_void_1(self): - # this is all in python - f = my_feval() - f.eval() - self.assertEqual(True, f.fired) - - def test_void_2(self): - # this is python -> C++ -> python and back again - f = my_feval() - gr.feval_example(f) - self.assertEqual(True, f.fired) - - -if __name__ == '__main__': - gr_unittest.run(test_feval, "test_feval.xml") diff --git a/gnuradio-runtime/python/gnuradio/gr/qa_flowgraph.py b/gnuradio-runtime/python/gnuradio/gr/qa_flowgraph.py index e5767e05d8..c92bea241e 100644 --- a/gnuradio-runtime/python/gnuradio/gr/qa_flowgraph.py +++ b/gnuradio-runtime/python/gnuradio/gr/qa_flowgraph.py @@ -40,7 +40,7 @@ class test_flowgraph (gr_unittest.TestCase): self.assertEqual(dbg.num_messages(), 1) data = pmt.u8vector_elements(pmt.cdr(dbg.get_message(0))) - self.assertEqual((1, 2, 3), data) + self.assertEqual([1, 2, 3], data) if __name__ == '__main__': gr_unittest.run(test_flowgraph, 'test_flowgraph.xml') diff --git a/gnuradio-runtime/python/gnuradio/gr/tag_utils.py b/gnuradio-runtime/python/gnuradio/gr/tag_utils.py index cdb3350ed0..26fd62b864 100644 --- a/gnuradio-runtime/python/gnuradio/gr/tag_utils.py +++ b/gnuradio-runtime/python/gnuradio/gr/tag_utils.py @@ -1,7 +1,7 @@ from __future__ import unicode_literals import pmt -from . import runtime_swig as gr +from . import gr_python as gr class PythonTag(object): " Python container for tags " @@ -58,17 +58,17 @@ def python_to_tag(tag_struct): good = True if('key' in tag_struct): - if(isinstance(tag_struct['key'], pmt.swig_pmt_ptr)): + if(isinstance(tag_struct['key'], pmt.pmt_base)): tag.key = tag_struct['key'] good = True if('value' in tag_struct): - if(isinstance(tag_struct['value'], pmt.swig_pmt_ptr)): + if(isinstance(tag_struct['value'], pmt.pmt_base)): tag.value = tag_struct['value'] good = True if('srcid' in tag_struct): - if(isinstance(tag_struct['srcid'], pmt.swig_pmt_ptr)): + if(isinstance(tag_struct['srcid'], pmt.pmt_base)): tag.srcid = tag_struct['srcid'] good = True @@ -78,15 +78,15 @@ def python_to_tag(tag_struct): tag.offset = tag_struct[0] good = True - if(isinstance(tag_struct[1], pmt.swig_pmt_ptr)): + if(isinstance(tag_struct[1], pmt.pmt_base)): tag.key = tag_struct[1] good = True - if(isinstance(tag_struct[2], pmt.swig_pmt_ptr)): + if(isinstance(tag_struct[2], pmt.pmt_base)): tag.value = tag_struct[2] good = True - if(isinstance(tag_struct[3], pmt.swig_pmt_ptr)): + if(isinstance(tag_struct[3], pmt.pmt_base)): tag.srcid = tag_struct[3] good = True @@ -95,11 +95,11 @@ def python_to_tag(tag_struct): tag.offset = tag_struct[0] good = True - if(isinstance(tag_struct[1], pmt.swig_pmt_ptr)): + if(isinstance(tag_struct[1], pmt.pmt_base)): tag.key = tag_struct[1] good = True - if(isinstance(tag_struct[2], pmt.swig_pmt_ptr)): + if(isinstance(tag_struct[2], pmt.pmt_base)): tag.value = tag_struct[2] good = True @@ -112,33 +112,33 @@ def python_to_tag(tag_struct): def tag_t_offset_compare_key(): """ - Convert a tag_t_offset_compare function into a key=function + Convert a tag_t.offset_compare function into a key=function This method is modeled after functools.cmp_to_key(_func_). It can be used by functions that accept a key function, such as sorted(), min(), max(), etc. to compare tags by their offsets, - e.g., sorted(tag_list, key=gr.tag_t_offset_compare_key()). + e.g., sorted(tag_list, key=gr.tag_t.offset_compare_key()). """ class K(object): def __init__(self, obj, *args): self.obj = obj def __lt__(self, other): # x.offset < y.offset - return gr.tag_t_offset_compare(self.obj, other.obj) + return gr.tag_t.offset_compare(self.obj, other.obj) def __gt__(self, other): # y.offset < x.offset - return gr.tag_t_offset_compare(other.obj, self.obj) + return gr.tag_t.offset_compare(other.obj, self.obj) def __eq__(self, other): # not (x.offset < y.offset) and not (y.offset < x.offset) - return not gr.tag_t_offset_compare(self.obj, other.obj) and \ - not gr.tag_t_offset_compare(other.obj, self.obj) + return not gr.tag_t.offset_compare(self.obj, other.obj) and \ + not gr.tag_t.offset_compare(other.obj, self.obj) def __le__(self, other): # not (y.offset < x.offset) - return not gr.tag_t_offset_compare(other.obj, self.obj) + return not gr.tag_t.offset_compare(other.obj, self.obj) def __ge__(self, other): # not (x.offset < y.offset) - return not gr.tag_t_offset_compare(self.obj, other.obj) + return not gr.tag_t.offset_compare(self.obj, other.obj) def __ne__(self, other): # (x.offset < y.offset) or (y.offset < x.offset) - return gr.tag_t_offset_compare(self.obj, other.obj) or \ - gr.tag_t_offset_compare(other.obj, self.obj) + return gr.tag_t.offset_compare(self.obj, other.obj) or \ + gr.tag_t.offset_compare(other.obj, self.obj) return K diff --git a/gnuradio-runtime/python/gnuradio/gr/top_block.py b/gnuradio-runtime/python/gnuradio/gr/top_block.py index e8a18b2d07..9523e4e91d 100644 --- a/gnuradio-runtime/python/gnuradio/gr/top_block.py +++ b/gnuradio-runtime/python/gnuradio/gr/top_block.py @@ -10,11 +10,12 @@ from __future__ import absolute_import from __future__ import unicode_literals -from .runtime_swig import (top_block_swig, +from .gr_python import (top_block_pb, top_block_wait_unlocked, top_block_run_unlocked, top_block_start_unlocked, top_block_stop_unlocked, - top_block_unlock_unlocked, dot_graph_tb) + top_block_unlock_unlocked) #, dot_graph_tb) +from .hier_block2 import hier_block2 import threading from .hier_block2 import hier_block2 @@ -89,7 +90,7 @@ class top_block(hier_block2): Create a top block with a given name. """ # not calling hier_block2.__init__, we set our own _impl - self._impl = top_block_swig(name, catch_exceptions) + self._impl = top_block_pb(name) self.handle_sigint = True def start(self, max_noutput_items=10000000): @@ -123,8 +124,8 @@ class top_block(hier_block2): """ _top_block_waiter(self._impl).wait(self.handle_sigint) - def dot_graph(self): - """ - Return graph representation in dot language - """ - return dot_graph_tb(self._impl) + # def dot_graph(self): + # """ + # Return graph representation in dot language + # """ + # return dot_graph_tb(self._impl) diff --git a/gnuradio-runtime/python/pmt/CMakeLists.txt b/gnuradio-runtime/python/pmt/CMakeLists.txt index cbbce43df0..3dcec8246b 100644 --- a/gnuradio-runtime/python/pmt/CMakeLists.txt +++ b/gnuradio-runtime/python/pmt/CMakeLists.txt @@ -26,10 +26,10 @@ foreach(py_qa_test_file ${py_qa_test_files}) get_filename_component(py_qa_test_name ${py_qa_test_file} NAME_WE) set(GR_TEST_PYTHON_DIRS ${CMAKE_BINARY_DIR}/gnuradio-runtime/python - ${CMAKE_BINARY_DIR}/gnuradio-runtime/swig - ${CMAKE_BINARY_DIR}/gnuradio-blocks/swig ) set(GR_TEST_TARGET_DEPS gnuradio-runtime) GR_ADD_TEST(${py_qa_test_name} ${QA_PYTHON_EXECUTABLE} -B ${py_qa_test_file}) endforeach(py_qa_test_file) endif(ENABLE_TESTING) + +add_subdirectory(bindings) diff --git a/gnuradio-runtime/python/pmt/__init__.py b/gnuradio-runtime/python/pmt/__init__.py index 05046f05d9..9b3b6f5410 100644 --- a/gnuradio-runtime/python/pmt/__init__.py +++ b/gnuradio-runtime/python/pmt/__init__.py @@ -33,11 +33,11 @@ from __future__ import unicode_literals import os try: - from .pmt_swig import * + from .pmt_python import * except ImportError: dirname, filename = os.path.split(os.path.abspath(__file__)) - __path__.append(os.path.join(dirname, "..", "..", "swig")) - from .pmt_swig import * + __path__.append(os.path.join(dirname, "bindings")) + from .pmt_python import * # due to changes in the PMT_NIL singleton for static builds, we force # this into Python here. diff --git a/gnuradio-runtime/python/pmt/bindings/CMakeLists.txt b/gnuradio-runtime/python/pmt/bindings/CMakeLists.txt new file mode 100644 index 0000000000..267d451d0b --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/CMakeLists.txt @@ -0,0 +1,18 @@ +include(GrPybind) + +######################################################################## +# Python Bindings +######################################################################## +list(APPEND pmt_python_files + pmt_python.cc + pmt_pool_python.cc + pmt_sugar_python.cc + python_bindings.cc +) + +GR_PYBIND_MAKE(pmt + ../../.. + pmt + "${pmt_python_files}") + +install(TARGETS pmt_python DESTINATION ${GR_PYTHON_DIR}/pmt COMPONENT pythonapi) diff --git a/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pool_pydoc_template.h b/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pool_pydoc_template.h new file mode 100644 index 0000000000..19c7fd4788 --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pool_pydoc_template.h @@ -0,0 +1,27 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(pmt, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_pmt_pmt_pool = R"doc()doc"; + + +static const char* __doc_pmt_pmt_pool_pmt_pool = R"doc()doc"; + + +static const char* __doc_pmt_pmt_pool_malloc = R"doc()doc"; + + +static const char* __doc_pmt_pmt_pool_free = R"doc()doc"; diff --git a/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pydoc_template.h b/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pydoc_template.h new file mode 100644 index 0000000000..6af2f9e0af --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pydoc_template.h @@ -0,0 +1,882 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(pmt, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_pmt_pmt_base = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_pmt_base = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_bool = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_symbol = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_number = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_integer = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_uint64 = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_real = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_complex = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_null = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_pair = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_tuple = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_dict = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_any = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_uniform_vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_u8vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_s8vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_u16vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_s16vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_u32vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_s32vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_u64vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_s64vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_f32vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_f64vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_c32vector = R"doc()doc"; + + +static const char* __doc_pmt_pmt_base_is_c64vector = R"doc()doc"; + + +static const char* __doc_pmt_exception = R"doc()doc"; + + +static const char* __doc_pmt_exception_exception_0 = R"doc()doc"; + + +static const char* __doc_pmt_exception_exception_1 = R"doc()doc"; + + +static const char* __doc_pmt_wrong_type = R"doc()doc"; + + +static const char* __doc_pmt_wrong_type_wrong_type_0 = R"doc()doc"; + + +static const char* __doc_pmt_wrong_type_wrong_type_1 = R"doc()doc"; + + +static const char* __doc_pmt_out_of_range = R"doc()doc"; + + +static const char* __doc_pmt_out_of_range_out_of_range_0 = R"doc()doc"; + + +static const char* __doc_pmt_out_of_range_out_of_range_1 = R"doc()doc"; + + +static const char* __doc_pmt_notimplemented = R"doc()doc"; + + +static const char* __doc_pmt_notimplemented_notimplemented_0 = R"doc()doc"; + + +static const char* __doc_pmt_notimplemented_notimplemented_1 = R"doc()doc"; + + +static const char* __doc_pmt_comparator = R"doc()doc"; + + +static const char* __doc_pmt_comparator_comparator_0 = R"doc()doc"; + + +static const char* __doc_pmt_comparator_comparator_1 = R"doc()doc"; + + +static const char* __doc_pmt_get_PMT_NIL = R"doc()doc"; + + +static const char* __doc_pmt_get_PMT_T = R"doc()doc"; + + +static const char* __doc_pmt_get_PMT_F = R"doc()doc"; + + +static const char* __doc_pmt_get_PMT_EOF = R"doc()doc"; + + +static const char* __doc_pmt_is_bool = R"doc()doc"; + + +static const char* __doc_pmt_is_true = R"doc()doc"; + + +static const char* __doc_pmt_is_false = R"doc()doc"; + + +static const char* __doc_pmt_from_bool = R"doc()doc"; + + +static const char* __doc_pmt_to_bool = R"doc()doc"; + + +static const char* __doc_pmt_is_symbol = R"doc()doc"; + + +static const char* __doc_pmt_string_to_symbol = R"doc()doc"; + + +static const char* __doc_pmt_intern = R"doc()doc"; + + +static const char* __doc_pmt_symbol_to_string = R"doc()doc"; + + +static const char* __doc_pmt_is_number = R"doc()doc"; + + +static const char* __doc_pmt_is_integer = R"doc()doc"; + + +static const char* __doc_pmt_from_long = R"doc()doc"; + + +static const char* __doc_pmt_to_long = R"doc()doc"; + + +static const char* __doc_pmt_is_uint64 = R"doc()doc"; + + +static const char* __doc_pmt_from_uint64 = R"doc()doc"; + + +static const char* __doc_pmt_to_uint64 = R"doc()doc"; + + +static const char* __doc_pmt_is_real = R"doc()doc"; + + +static const char* __doc_pmt_from_double = R"doc()doc"; + + +static const char* __doc_pmt_from_float = R"doc()doc"; + + +static const char* __doc_pmt_to_double = R"doc()doc"; + + +static const char* __doc_pmt_to_float = R"doc()doc"; + + +static const char* __doc_pmt_is_complex = R"doc()doc"; + + +static const char* __doc_pmt_make_rectangular = R"doc()doc"; + + +static const char* __doc_pmt_from_complex_0 = R"doc()doc"; + + +static const char* __doc_pmt_from_complex_1 = R"doc()doc"; + + +static const char* __doc_pmt_pmt_from_complex_0 = R"doc()doc"; + + +static const char* __doc_pmt_pmt_from_complex_1 = R"doc()doc"; + + +static const char* __doc_pmt_to_complex = R"doc()doc"; + + +static const char* __doc_pmt_is_null = R"doc()doc"; + + +static const char* __doc_pmt_is_pair = R"doc()doc"; + + +static const char* __doc_pmt_cons = R"doc()doc"; + + +static const char* __doc_pmt_dcons = R"doc()doc"; + + +static const char* __doc_pmt_car = R"doc()doc"; + + +static const char* __doc_pmt_cdr = R"doc()doc"; + + +static const char* __doc_pmt_set_car = R"doc()doc"; + + +static const char* __doc_pmt_set_cdr = R"doc()doc"; + + +static const char* __doc_pmt_caar = R"doc()doc"; + + +static const char* __doc_pmt_cadr = R"doc()doc"; + + +static const char* __doc_pmt_cdar = R"doc()doc"; + + +static const char* __doc_pmt_cddr = R"doc()doc"; + + +static const char* __doc_pmt_caddr = R"doc()doc"; + + +static const char* __doc_pmt_cadddr = R"doc()doc"; + + +static const char* __doc_pmt_is_tuple = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_0 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_1 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_2 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_3 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_4 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_5 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_6 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_7 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_8 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_9 = R"doc()doc"; + + +static const char* __doc_pmt_make_tuple_10 = R"doc()doc"; + + +static const char* __doc_pmt_to_tuple = R"doc()doc"; + + +static const char* __doc_pmt_tuple_ref = R"doc()doc"; + + +static const char* __doc_pmt_is_vector = R"doc()doc"; + + +static const char* __doc_pmt_make_vector = R"doc()doc"; + + +static const char* __doc_pmt_vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_vector_set = R"doc()doc"; + + +static const char* __doc_pmt_vector_fill = R"doc()doc"; + + +static const char* __doc_pmt_is_blob = R"doc()doc"; + + +static const char* __doc_pmt_make_blob = R"doc()doc"; + + +static const char* __doc_pmt_blob_data = R"doc()doc"; + + +static const char* __doc_pmt_blob_length = R"doc()doc"; + + +static const char* __doc_pmt_is_uniform_vector = R"doc()doc"; + + +static const char* __doc_pmt_is_u8vector = R"doc()doc"; + + +static const char* __doc_pmt_is_s8vector = R"doc()doc"; + + +static const char* __doc_pmt_is_u16vector = R"doc()doc"; + + +static const char* __doc_pmt_is_s16vector = R"doc()doc"; + + +static const char* __doc_pmt_is_u32vector = R"doc()doc"; + + +static const char* __doc_pmt_is_s32vector = R"doc()doc"; + + +static const char* __doc_pmt_is_u64vector = R"doc()doc"; + + +static const char* __doc_pmt_is_s64vector = R"doc()doc"; + + +static const char* __doc_pmt_is_f32vector = R"doc()doc"; + + +static const char* __doc_pmt_is_f64vector = R"doc()doc"; + + +static const char* __doc_pmt_is_c32vector = R"doc()doc"; + + +static const char* __doc_pmt_is_c64vector = R"doc()doc"; + + +static const char* __doc_pmt_uniform_vector_itemsize = R"doc()doc"; + + +static const char* __doc_pmt_make_u8vector = R"doc()doc"; + + +static const char* __doc_pmt_make_s8vector = R"doc()doc"; + + +static const char* __doc_pmt_make_u16vector = R"doc()doc"; + + +static const char* __doc_pmt_make_s16vector = R"doc()doc"; + + +static const char* __doc_pmt_make_u32vector = R"doc()doc"; + + +static const char* __doc_pmt_make_s32vector = R"doc()doc"; + + +static const char* __doc_pmt_make_u64vector = R"doc()doc"; + + +static const char* __doc_pmt_make_s64vector = R"doc()doc"; + + +static const char* __doc_pmt_make_f32vector = R"doc()doc"; + + +static const char* __doc_pmt_make_f64vector = R"doc()doc"; + + +static const char* __doc_pmt_make_c32vector = R"doc()doc"; + + +static const char* __doc_pmt_make_c64vector = R"doc()doc"; + + +static const char* __doc_pmt_init_u8vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_u8vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_s8vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_s8vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_u16vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_u16vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_s16vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_s16vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_u32vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_u32vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_s32vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_s32vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_u64vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_u64vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_s64vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_s64vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_f32vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_f32vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_f64vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_f64vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_c32vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_c32vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_init_c64vector_0 = R"doc()doc"; + + +static const char* __doc_pmt_init_c64vector_1 = R"doc()doc"; + + +static const char* __doc_pmt_u8vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_s8vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_u16vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_s16vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_u32vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_s32vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_u64vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_s64vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_f32vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_f64vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_c32vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_c64vector_ref = R"doc()doc"; + + +static const char* __doc_pmt_u8vector_set = R"doc()doc"; + + +static const char* __doc_pmt_s8vector_set = R"doc()doc"; + + +static const char* __doc_pmt_u16vector_set = R"doc()doc"; + + +static const char* __doc_pmt_s16vector_set = R"doc()doc"; + + +static const char* __doc_pmt_u32vector_set = R"doc()doc"; + + +static const char* __doc_pmt_s32vector_set = R"doc()doc"; + + +static const char* __doc_pmt_u64vector_set = R"doc()doc"; + + +static const char* __doc_pmt_s64vector_set = R"doc()doc"; + + +static const char* __doc_pmt_f32vector_set = R"doc()doc"; + + +static const char* __doc_pmt_f64vector_set = R"doc()doc"; + + +static const char* __doc_pmt_c32vector_set = R"doc()doc"; + + +static const char* __doc_pmt_c64vector_set = R"doc()doc"; + + +static const char* __doc_pmt_uniform_vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_u8vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_s8vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_u16vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_s16vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_u32vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_s32vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_u64vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_s64vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_f32vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_f64vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_c32vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_c64vector_elements_0 = R"doc()doc"; + + +static const char* __doc_pmt_u8vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_s8vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_u16vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_s16vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_u32vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_s32vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_u64vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_s64vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_f32vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_f64vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_c32vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_c64vector_elements_1 = R"doc()doc"; + + +static const char* __doc_pmt_pmt_u8vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_s8vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_u16vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_s16vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_u32vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_s32vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_u64vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_s64vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_f32vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_f64vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_c32vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_pmt_c64vector_elements = R"doc()doc"; + + +static const char* __doc_pmt_uniform_vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_u8vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_s8vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_u16vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_s16vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_u32vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_s32vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_u64vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_s64vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_f32vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_f64vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_c32vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_c64vector_writable_elements = R"doc()doc"; + + +static const char* __doc_pmt_is_dict = R"doc()doc"; + + +static const char* __doc_pmt_make_dict = R"doc()doc"; + + +static const char* __doc_pmt_dict_add = R"doc()doc"; + + +static const char* __doc_pmt_dict_delete = R"doc()doc"; + + +static const char* __doc_pmt_dict_has_key = R"doc()doc"; + + +static const char* __doc_pmt_dict_ref = R"doc()doc"; + + +static const char* __doc_pmt_dict_items = R"doc()doc"; + + +static const char* __doc_pmt_dict_keys = R"doc()doc"; + + +static const char* __doc_pmt_dict_update = R"doc()doc"; + + +static const char* __doc_pmt_dict_values = R"doc()doc"; + + +static const char* __doc_pmt_is_any = R"doc()doc"; + + +static const char* __doc_pmt_make_any = R"doc()doc"; + + +static const char* __doc_pmt_any_ref = R"doc()doc"; + + +static const char* __doc_pmt_any_set = R"doc()doc"; + + +static const char* __doc_pmt_is_msg_accepter = R"doc()doc"; + + +static const char* __doc_pmt_make_msg_accepter = R"doc()doc"; + + +static const char* __doc_pmt_msg_accepter_ref = R"doc()doc"; + + +static const char* __doc_pmt_is_pdu = R"doc()doc"; + + +static const char* __doc_pmt_eq = R"doc()doc"; + + +static const char* __doc_pmt_eqv = R"doc()doc"; + + +static const char* __doc_pmt_equal = R"doc()doc"; + + +static const char* __doc_pmt_assq = R"doc()doc"; + + +static const char* __doc_pmt_assv = R"doc()doc"; + + +static const char* __doc_pmt_assoc = R"doc()doc"; + + +static const char* __doc_pmt_map = R"doc()doc"; + + +static const char* __doc_pmt_reverse = R"doc()doc"; + + +static const char* __doc_pmt_reverse_x = R"doc()doc"; + + +static const char* __doc_pmt_acons = R"doc()doc"; + + +static const char* __doc_pmt_nth = R"doc()doc"; + + +static const char* __doc_pmt_nthcdr = R"doc()doc"; + + +static const char* __doc_pmt_memq = R"doc()doc"; + + +static const char* __doc_pmt_memv = R"doc()doc"; + + +static const char* __doc_pmt_member = R"doc()doc"; + + +static const char* __doc_pmt_subsetp = R"doc()doc"; + + +static const char* __doc_pmt_list1 = R"doc()doc"; + + +static const char* __doc_pmt_list2 = R"doc()doc"; + + +static const char* __doc_pmt_list3 = R"doc()doc"; + + +static const char* __doc_pmt_list4 = R"doc()doc"; + + +static const char* __doc_pmt_list5 = R"doc()doc"; + + +static const char* __doc_pmt_list6 = R"doc()doc"; + + +static const char* __doc_pmt_list_add = R"doc()doc"; + + +static const char* __doc_pmt_list_rm = R"doc()doc"; + + +static const char* __doc_pmt_list_has = R"doc()doc"; + + +static const char* __doc_pmt_is_eof_object = R"doc()doc"; + + +static const char* __doc_pmt_read = R"doc()doc"; + + +static const char* __doc_pmt_write = R"doc()doc"; + + +static const char* __doc_pmt_write_string = R"doc()doc"; + + +static const char* __doc_pmt_print = R"doc()doc"; + + +static const char* __doc_pmt_serialize = R"doc()doc"; + + +static const char* __doc_pmt_deserialize = R"doc()doc"; + + +static const char* __doc_pmt_dump_sizeof = R"doc()doc"; + + +static const char* __doc_pmt_serialize_str = R"doc()doc"; + + +static const char* __doc_pmt_deserialize_str = R"doc()doc"; diff --git a/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_sugar_pydoc_template.h b/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_sugar_pydoc_template.h new file mode 100644 index 0000000000..2134d6f3e1 --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_sugar_pydoc_template.h @@ -0,0 +1,78 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ +#include "pydoc_macros.h" +#define D(...) DOC(pmt, __VA_ARGS__) +/* + This file contains placeholders for docstrings for the Python bindings. + Do not edit! These were automatically extracted during the binding process + and will be overwritten during the build process + */ + + +static const char* __doc_pmt_mp_0 = R"doc()doc"; + + +static const char* __doc_pmt_mp_1 = R"doc()doc"; + + +static const char* __doc_pmt_mp_2 = R"doc()doc"; + + +static const char* __doc_pmt_mp_3 = R"doc()doc"; + + +static const char* __doc_pmt_mp_4 = R"doc()doc"; + + +static const char* __doc_pmt_mp_5 = R"doc()doc"; + + +static const char* __doc_pmt_mp_6 = R"doc()doc"; + + +static const char* __doc_pmt_mp_7 = R"doc()doc"; + + +static const char* __doc_pmt_mp_8 = R"doc()doc"; + + +static const char* __doc_pmt_mp_9 = R"doc()doc"; + + +static const char* __doc_pmt_mp_10 = R"doc()doc"; + + +static const char* __doc_pmt_mp_11 = R"doc()doc"; + + +static const char* __doc_pmt_mp_12 = R"doc()doc"; + + +static const char* __doc_pmt_mp_13 = R"doc()doc"; + + +static const char* __doc_pmt_mp_14 = R"doc()doc"; + + +static const char* __doc_pmt_mp_15 = R"doc()doc"; + + +static const char* __doc_pmt_mp_16 = R"doc()doc"; + + +static const char* __doc_pmt_mp_17 = R"doc()doc"; + + +static const char* __doc_pmt_mp_18 = R"doc()doc"; + + +static const char* __doc_pmt_mp_19 = R"doc()doc"; + + +static const char* __doc_pmt_mp_20 = R"doc()doc"; diff --git a/gnuradio-runtime/python/pmt/bindings/pmt_pool_python.cc b/gnuradio-runtime/python/pmt/bindings/pmt_pool_python.cc new file mode 100644 index 0000000000..c6c8f71f5f --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/pmt_pool_python.cc @@ -0,0 +1,42 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <pmt/pmt_pool.h> +// pydoc.h is automatically generated in the build directory +#include <pmt_pool_pydoc.h> + +void bind_pmt_pool(py::module& m) +{ + + using pmt_pool = ::pmt::pmt_pool; + + + py::class_<pmt_pool, std::shared_ptr<pmt_pool>>(m, "pmt_pool", D(pmt_pool)) + + .def(py::init<size_t, size_t, size_t, size_t>(), + py::arg("itemsize"), + py::arg("alignment") = 16, + py::arg("allocation_size") = 4096, + py::arg("max_items") = 0, + D(pmt_pool, pmt_pool)) + + + .def("malloc", &pmt_pool::malloc, D(pmt_pool, malloc)) + + + .def("free", &pmt_pool::free, py::arg("p"), D(pmt_pool, free)); +} diff --git a/gnuradio-runtime/python/pmt/bindings/pmt_python.cc b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc new file mode 100644 index 0000000000..7cb1e530d3 --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc @@ -0,0 +1,1558 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <pmt/pmt.h> +// pydoc.h is automatically generated in the build directory +#include <pmt_pydoc.h> + +void bind_pmt(py::module& m) +{ + using pmt_base = pmt::pmt_base; + // using exception = pmt::exception; + // using wrong_type = pmt::wrong_type; + // using out_of_range = pmt::out_of_range; + // using notimplemented = pmt::notimplemented; + using comparator = pmt::comparator; + + py::class_<pmt_base, std::shared_ptr<pmt_base>>(m, "pmt_base") + + .def(py::init<>(), D(pmt_base, pmt_base)) + .def("__str__", [](const pmt::pmt_t& p) { return pmt::write_string(p); }) + .def("is_bool", &pmt_base::is_bool, D(pmt_base, is_bool)) + + + .def("is_symbol", &pmt_base::is_symbol, D(pmt_base, is_symbol)) + + + .def("is_number", &pmt_base::is_number, D(pmt_base, is_number)) + + + .def("is_integer", &pmt_base::is_integer, D(pmt_base, is_integer)) + + + .def("is_uint64", &pmt_base::is_uint64, D(pmt_base, is_uint64)) + + + .def("is_real", &pmt_base::is_real, D(pmt_base, is_real)) + + + .def("is_complex", &pmt_base::is_complex, D(pmt_base, is_complex)) + + + .def("is_null", &pmt_base::is_null, D(pmt_base, is_null)) + + + .def("is_pair", &pmt_base::is_pair, D(pmt_base, is_pair)) + + + .def("is_tuple", &pmt_base::is_tuple, D(pmt_base, is_tuple)) + + + .def("is_vector", &pmt_base::is_vector, D(pmt_base, is_vector)) + + + .def("is_dict", &pmt_base::is_dict, D(pmt_base, is_dict)) + + + .def("is_any", &pmt_base::is_any, D(pmt_base, is_any)) + + + .def("is_uniform_vector", + &pmt_base::is_uniform_vector, + D(pmt_base, is_uniform_vector)) + + + .def("is_u8vector", &pmt_base::is_u8vector, D(pmt_base, is_u8vector)) + + + .def("is_s8vector", &pmt_base::is_s8vector, D(pmt_base, is_s8vector)) + + + .def("is_u16vector", &pmt_base::is_u16vector, D(pmt_base, is_u16vector)) + + + .def("is_s16vector", &pmt_base::is_s16vector, D(pmt_base, is_s16vector)) + + + .def("is_u32vector", &pmt_base::is_u32vector, D(pmt_base, is_u32vector)) + + + .def("is_s32vector", &pmt_base::is_s32vector, D(pmt_base, is_s32vector)) + + + .def("is_u64vector", &pmt_base::is_u64vector, D(pmt_base, is_u64vector)) + + + .def("is_s64vector", &pmt_base::is_s64vector, D(pmt_base, is_s64vector)) + + + .def("is_f32vector", &pmt_base::is_f32vector, D(pmt_base, is_f32vector)) + + + .def("is_f64vector", &pmt_base::is_f64vector, D(pmt_base, is_f64vector)) + + + .def("is_c32vector", &pmt_base::is_c32vector, D(pmt_base, is_c32vector)) + + + .def("is_c64vector", &pmt_base::is_c64vector, D(pmt_base, is_c64vector)) + + ; + + + // py::class_<exception,std::logic_error, + // std::shared_ptr<exception>>(m, "exception") + + // .def(py::init<std::string const &,pmt::pmt_t>(), py::arg("msg"), + // py::arg("obj") + // ) + // .def(py::init<pmt::exception const &>(), py::arg("arg0") + // ) + + // ; + + + // py::class_<wrong_type,pmt::exception, + // std::shared_ptr<wrong_type>>(m, "wrong_type") + + // .def(py::init<std::string const &,pmt::pmt_t>(), py::arg("msg"), + // py::arg("obj") + // ) + // .def(py::init<pmt::wrong_type const &>(), py::arg("arg0") + // ) + + // ; + + + // py::class_<out_of_range,pmt::exception, + // std::shared_ptr<out_of_range>>(m, "out_of_range") + + // .def(py::init<std::string const &,pmt::pmt_t>(), py::arg("msg"), + // py::arg("obj") + // ) + // .def(py::init<pmt::out_of_range const &>(), py::arg("arg0") + // ) + + // ; + + + // py::class_<notimplemented,pmt::exception, + // std::shared_ptr<notimplemented>>(m, "notimplemented") + + // .def(py::init<std::string const &,pmt::pmt_t>(), py::arg("msg"), + // py::arg("obj") + // ) + // .def(py::init<pmt::notimplemented const &>(), py::arg("arg0") + // ) + + // ; + + + py::class_<comparator, std::shared_ptr<comparator>>(m, "comparator") + + .def(py::init<>()) + .def(py::init<pmt::comparator const&>(), py::arg("arg0")) + + ; + + + m.def("get_PMT_NIL", &::pmt::get_PMT_NIL, D(get_PMT_NIL)); + + + m.def("get_PMT_T", &::pmt::get_PMT_T, D(get_PMT_T)); + + + m.def("get_PMT_F", &::pmt::get_PMT_F, D(get_PMT_F)); + + + m.def("get_PMT_EOF", &::pmt::get_PMT_EOF, D(get_PMT_EOF)); + + + m.def("is_bool", &::pmt::is_bool, py::arg("obj"), D(is_bool)); + + + m.def("is_true", &::pmt::is_true, py::arg("obj"), D(is_true)); + + + m.def("is_false", &::pmt::is_false, py::arg("obj"), D(is_false)); + + + m.def("from_bool", &::pmt::from_bool, py::arg("val"), D(from_bool)); + + + m.def("to_bool", &::pmt::to_bool, py::arg("val"), D(to_bool)); + + + m.def("is_symbol", &::pmt::is_symbol, py::arg("obj"), D(is_symbol)); + + + m.def( + "string_to_symbol", &::pmt::string_to_symbol, py::arg("s"), D(string_to_symbol)); + + + m.def("intern", &::pmt::intern, py::arg("s"), D(intern)); + + + m.def("symbol_to_string", + &::pmt::symbol_to_string, + py::arg("sym"), + D(symbol_to_string)); + + + m.def("is_number", &::pmt::is_number, py::arg("obj"), D(is_number)); + + + m.def("is_integer", &::pmt::is_integer, py::arg("x"), D(is_integer)); + + + m.def("from_long", &::pmt::from_long, py::arg("x"), D(from_long)); + + + m.def("to_long", &::pmt::to_long, py::arg("x"), D(to_long)); + + + m.def("is_uint64", &::pmt::is_uint64, py::arg("x"), D(is_uint64)); + + + m.def("from_uint64", &::pmt::from_uint64, py::arg("x"), D(from_uint64)); + + + m.def("to_uint64", &::pmt::to_uint64, py::arg("x"), D(to_uint64)); + + + m.def("is_real", &::pmt::is_real, py::arg("obj"), D(is_real)); + + + m.def("from_double", &::pmt::from_double, py::arg("x"), D(from_double)); + + + m.def("from_float", &::pmt::from_float, py::arg("x"), D(from_float)); + + + m.def("to_double", &::pmt::to_double, py::arg("x"), D(to_double)); + + + m.def("to_float", &::pmt::to_float, py::arg("x"), D(to_float)); + + + m.def("is_complex", &::pmt::is_complex, py::arg("obj"), D(is_complex)); + + + m.def("make_rectangular", + &::pmt::make_rectangular, + py::arg("re"), + py::arg("im"), + D(make_rectangular)); + + + m.def("from_complex", + (pmt::pmt_t(*)(double, double)) & ::pmt::from_complex, + py::arg("re"), + py::arg("im"), + D(from_complex, 0)); + + + m.def("from_complex", + (pmt::pmt_t(*)(std::complex<double> const&)) & ::pmt::from_complex, + py::arg("z"), + D(from_complex, 1)); + + + m.def("pmt_from_complex", + (pmt::pmt_t(*)(double, double)) & ::pmt::pmt_from_complex, + py::arg("re"), + py::arg("im"), + D(pmt_from_complex, 0)); + + + m.def("pmt_from_complex", + (pmt::pmt_t(*)(std::complex<double> const&)) & ::pmt::pmt_from_complex, + py::arg("z"), + D(pmt_from_complex, 1)); + + + m.def("to_complex", &::pmt::to_complex, py::arg("z"), D(to_complex)); + + + m.def("is_null", &::pmt::is_null, py::arg("x"), D(is_null)); + + + m.def("is_pair", &::pmt::is_pair, py::arg("obj"), D(is_pair)); + + + m.def("cons", &::pmt::cons, py::arg("x"), py::arg("y"), D(cons)); + + + m.def("dcons", &::pmt::dcons, py::arg("x"), py::arg("y"), D(dcons)); + + + m.def("car", &::pmt::car, py::arg("pair"), D(car)); + + + m.def("cdr", &::pmt::cdr, py::arg("pair"), D(cdr)); + + + m.def("set_car", &::pmt::set_car, py::arg("pair"), py::arg("value"), D(set_car)); + + + m.def("set_cdr", &::pmt::set_cdr, py::arg("pair"), py::arg("value"), D(set_cdr)); + + + m.def("caar", &::pmt::caar, py::arg("pair"), D(caar)); + + + m.def("cadr", &::pmt::cadr, py::arg("pair"), D(cadr)); + + + m.def("cdar", &::pmt::cdar, py::arg("pair"), D(cdar)); + + + m.def("cddr", &::pmt::cddr, py::arg("pair"), D(cddr)); + + + m.def("caddr", &::pmt::caddr, py::arg("pair"), D(caddr)); + + + m.def("cadddr", &::pmt::cadddr, py::arg("pair"), D(cadddr)); + + + m.def("is_tuple", &::pmt::is_tuple, py::arg("x"), D(is_tuple)); + + + m.def("make_tuple", (pmt::pmt_t(*)()) & ::pmt::make_tuple, D(make_tuple, 0)); + + + m.def("make_tuple", + (pmt::pmt_t(*)(pmt::pmt_t const&)) & ::pmt::make_tuple, + py::arg("e0"), + D(make_tuple, 1)); + + + m.def("make_tuple", + (pmt::pmt_t(*)(pmt::pmt_t const&, pmt::pmt_t const&)) & ::pmt::make_tuple, + py::arg("e0"), + py::arg("e1"), + D(make_tuple, 2)); + + + m.def("make_tuple", + (pmt::pmt_t(*)(pmt::pmt_t const&, pmt::pmt_t const&, pmt::pmt_t const&)) & + ::pmt::make_tuple, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + D(make_tuple, 3)); + + + m.def( + "make_tuple", + (pmt::pmt_t(*)( + pmt::pmt_t const&, pmt::pmt_t const&, pmt::pmt_t const&, pmt::pmt_t const&)) & + ::pmt::make_tuple, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + D(make_tuple, 4)); + + + m.def("make_tuple", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::make_tuple, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + D(make_tuple, 5)); + + + m.def("make_tuple", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::make_tuple, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + D(make_tuple, 6)); + + + m.def("make_tuple", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::make_tuple, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + py::arg("e6"), + D(make_tuple, 7)); + + + m.def("make_tuple", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::make_tuple, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + py::arg("e6"), + py::arg("e7"), + D(make_tuple, 8)); + + + m.def("make_tuple", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::make_tuple, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + py::arg("e6"), + py::arg("e7"), + py::arg("e8"), + D(make_tuple, 9)); + + + m.def("make_tuple", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::make_tuple, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + py::arg("e6"), + py::arg("e7"), + py::arg("e8"), + py::arg("e9"), + D(make_tuple, 10)); + + + m.def("to_tuple", &::pmt::to_tuple, py::arg("x"), D(to_tuple)); + + + m.def("tuple_ref", &::pmt::tuple_ref, py::arg("tuple"), py::arg("k"), D(tuple_ref)); + + + m.def("is_vector", &::pmt::is_vector, py::arg("x"), D(is_vector)); + + + m.def("make_vector", + &::pmt::make_vector, + py::arg("k"), + py::arg("fill"), + D(make_vector)); + + + m.def( + "vector_ref", &::pmt::vector_ref, py::arg("vector"), py::arg("k"), D(vector_ref)); + + + m.def("vector_set", + &::pmt::vector_set, + py::arg("vector"), + py::arg("k"), + py::arg("obj"), + D(vector_set)); + + + m.def("vector_fill", + &::pmt::vector_fill, + py::arg("vector"), + py::arg("fill"), + D(vector_fill)); + + + m.def("is_blob", &::pmt::is_blob, py::arg("x"), D(is_blob)); + + + m.def("make_blob", &::pmt::make_blob, py::arg("buf"), py::arg("len"), D(make_blob)); + + + m.def("blob_data", &::pmt::blob_data, py::arg("blob"), D(blob_data)); + + + m.def("blob_length", &::pmt::blob_length, py::arg("blob"), D(blob_length)); + + + m.def("is_uniform_vector", + &::pmt::is_uniform_vector, + py::arg("x"), + D(is_uniform_vector)); + + + m.def("is_u8vector", &::pmt::is_u8vector, py::arg("x"), D(is_u8vector)); + + + m.def("is_s8vector", &::pmt::is_s8vector, py::arg("x"), D(is_s8vector)); + + + m.def("is_u16vector", &::pmt::is_u16vector, py::arg("x"), D(is_u16vector)); + + + m.def("is_s16vector", &::pmt::is_s16vector, py::arg("x"), D(is_s16vector)); + + + m.def("is_u32vector", &::pmt::is_u32vector, py::arg("x"), D(is_u32vector)); + + + m.def("is_s32vector", &::pmt::is_s32vector, py::arg("x"), D(is_s32vector)); + + + m.def("is_u64vector", &::pmt::is_u64vector, py::arg("x"), D(is_u64vector)); + + + m.def("is_s64vector", &::pmt::is_s64vector, py::arg("x"), D(is_s64vector)); + + + m.def("is_f32vector", &::pmt::is_f32vector, py::arg("x"), D(is_f32vector)); + + + m.def("is_f64vector", &::pmt::is_f64vector, py::arg("x"), D(is_f64vector)); + + + m.def("is_c32vector", &::pmt::is_c32vector, py::arg("x"), D(is_c32vector)); + + + m.def("is_c64vector", &::pmt::is_c64vector, py::arg("x"), D(is_c64vector)); + + + m.def("uniform_vector_itemsize", + &::pmt::uniform_vector_itemsize, + py::arg("x"), + D(uniform_vector_itemsize)); + + + m.def("make_u8vector", + &::pmt::make_u8vector, + py::arg("k"), + py::arg("fill"), + D(make_u8vector)); + + + m.def("make_s8vector", + &::pmt::make_s8vector, + py::arg("k"), + py::arg("fill"), + D(make_s8vector)); + + + m.def("make_u16vector", + &::pmt::make_u16vector, + py::arg("k"), + py::arg("fill"), + D(make_u16vector)); + + + m.def("make_s16vector", + &::pmt::make_s16vector, + py::arg("k"), + py::arg("fill"), + D(make_s16vector)); + + + m.def("make_u32vector", + &::pmt::make_u32vector, + py::arg("k"), + py::arg("fill"), + D(make_u32vector)); + + + m.def("make_s32vector", + &::pmt::make_s32vector, + py::arg("k"), + py::arg("fill"), + D(make_s32vector)); + + + m.def("make_u64vector", + &::pmt::make_u64vector, + py::arg("k"), + py::arg("fill"), + D(make_u64vector)); + + + m.def("make_s64vector", + &::pmt::make_s64vector, + py::arg("k"), + py::arg("fill"), + D(make_s64vector)); + + + m.def("make_f32vector", + &::pmt::make_f32vector, + py::arg("k"), + py::arg("fill"), + D(make_f32vector)); + + + m.def("make_f64vector", + &::pmt::make_f64vector, + py::arg("k"), + py::arg("fill"), + D(make_f64vector)); + + + m.def("make_c32vector", + &::pmt::make_c32vector, + py::arg("k"), + py::arg("fill"), + D(make_c32vector)); + + + m.def("make_c64vector", + &::pmt::make_c64vector, + py::arg("k"), + py::arg("fill"), + D(make_c64vector)); + + + m.def("init_u8vector", + (pmt::pmt_t(*)(size_t, uint8_t const*)) & ::pmt::init_u8vector, + py::arg("k"), + py::arg("data"), + D(init_u8vector, 0)); + + + m.def("init_u8vector", + (pmt::pmt_t(*)( + size_t, std::vector<unsigned char, std::allocator<unsigned char>> const&)) & + ::pmt::init_u8vector, + py::arg("k"), + py::arg("data"), + D(init_u8vector, 1)); + + + m.def("init_s8vector", + (pmt::pmt_t(*)(size_t, int8_t const*)) & ::pmt::init_s8vector, + py::arg("k"), + py::arg("data"), + D(init_s8vector, 0)); + + + m.def("init_s8vector", + (pmt::pmt_t(*)(size_t, + std::vector<signed char, std::allocator<signed char>> const&)) & + ::pmt::init_s8vector, + py::arg("k"), + py::arg("data"), + D(init_s8vector, 1)); + + + m.def("init_u16vector", + (pmt::pmt_t(*)(size_t, uint16_t const*)) & ::pmt::init_u16vector, + py::arg("k"), + py::arg("data"), + D(init_u16vector, 0)); + + + m.def( + "init_u16vector", + (pmt::pmt_t(*)( + size_t, std::vector<unsigned short, std::allocator<unsigned short>> const&)) & + ::pmt::init_u16vector, + py::arg("k"), + py::arg("data"), + D(init_u16vector, 1)); + + + m.def("init_s16vector", + (pmt::pmt_t(*)(size_t, int16_t const*)) & ::pmt::init_s16vector, + py::arg("k"), + py::arg("data"), + D(init_s16vector, 0)); + + + m.def("init_s16vector", + (pmt::pmt_t(*)(size_t, std::vector<short, std::allocator<short>> const&)) & + ::pmt::init_s16vector, + py::arg("k"), + py::arg("data"), + D(init_s16vector, 1)); + + + m.def("init_u32vector", + (pmt::pmt_t(*)(size_t, uint32_t const*)) & ::pmt::init_u32vector, + py::arg("k"), + py::arg("data"), + D(init_u32vector, 0)); + + + m.def("init_u32vector", + (pmt::pmt_t(*)( + size_t, std::vector<unsigned int, std::allocator<unsigned int>> const&)) & + ::pmt::init_u32vector, + py::arg("k"), + py::arg("data"), + D(init_u32vector, 1)); + + + m.def("init_s32vector", + (pmt::pmt_t(*)(size_t, int32_t const*)) & ::pmt::init_s32vector, + py::arg("k"), + py::arg("data"), + D(init_s32vector, 0)); + + + m.def("init_s32vector", + (pmt::pmt_t(*)(size_t, std::vector<int, std::allocator<int>> const&)) & + ::pmt::init_s32vector, + py::arg("k"), + py::arg("data"), + D(init_s32vector, 1)); + + + m.def("init_u64vector", + (pmt::pmt_t(*)(size_t, uint64_t const*)) & ::pmt::init_u64vector, + py::arg("k"), + py::arg("data"), + D(init_u64vector, 0)); + + + m.def( + "init_u64vector", + (pmt::pmt_t(*)(size_t, std::vector<uint64_t, std::allocator<uint64_t>> const&)) & + ::pmt::init_u64vector, + py::arg("k"), + py::arg("data"), + D(init_u64vector, 1)); + + + m.def("init_s64vector", + (pmt::pmt_t(*)(size_t, int64_t const*)) & ::pmt::init_s64vector, + py::arg("k"), + py::arg("data"), + D(init_s64vector, 0)); + + + m.def("init_s64vector", + (pmt::pmt_t(*)(size_t, std::vector<int64_t, std::allocator<int64_t>> const&)) & + ::pmt::init_s64vector, + py::arg("k"), + py::arg("data"), + D(init_s64vector, 1)); + + + m.def("init_f32vector", + (pmt::pmt_t(*)(size_t, float const*)) & ::pmt::init_f32vector, + py::arg("k"), + py::arg("data"), + D(init_f32vector, 0)); + + + m.def("init_f32vector", + (pmt::pmt_t(*)(size_t, std::vector<float, std::allocator<float>> const&)) & + ::pmt::init_f32vector, + py::arg("k"), + py::arg("data"), + D(init_f32vector, 1)); + + + m.def("init_f64vector", + (pmt::pmt_t(*)(size_t, double const*)) & ::pmt::init_f64vector, + py::arg("k"), + py::arg("data"), + D(init_f64vector, 0)); + + + m.def("init_f64vector", + (pmt::pmt_t(*)(size_t, std::vector<double, std::allocator<double>> const&)) & + ::pmt::init_f64vector, + py::arg("k"), + py::arg("data"), + D(init_f64vector, 1)); + + + m.def("init_c32vector", + (pmt::pmt_t(*)(size_t, std::complex<float> const*)) & ::pmt::init_c32vector, + py::arg("k"), + py::arg("data"), + D(init_c32vector, 0)); + + + m.def("init_c32vector", + (pmt::pmt_t(*)(size_t, + std::vector<std::complex<float>, + std::allocator<std::complex<float>>> const&)) & + ::pmt::init_c32vector, + py::arg("k"), + py::arg("data"), + D(init_c32vector, 1)); + + + m.def("init_c64vector", + (pmt::pmt_t(*)(size_t, std::complex<double> const*)) & ::pmt::init_c64vector, + py::arg("k"), + py::arg("data"), + D(init_c64vector, 0)); + + + m.def("init_c64vector", + (pmt::pmt_t(*)(size_t, + std::vector<std::complex<double>, + std::allocator<std::complex<double>>> const&)) & + ::pmt::init_c64vector, + py::arg("k"), + py::arg("data"), + D(init_c64vector, 1)); + + + m.def("u8vector_ref", + &::pmt::u8vector_ref, + py::arg("v"), + py::arg("k"), + D(u8vector_ref)); + + + m.def("s8vector_ref", + &::pmt::s8vector_ref, + py::arg("v"), + py::arg("k"), + D(s8vector_ref)); + + + m.def("u16vector_ref", + &::pmt::u16vector_ref, + py::arg("v"), + py::arg("k"), + D(u16vector_ref)); + + + m.def("s16vector_ref", + &::pmt::s16vector_ref, + py::arg("v"), + py::arg("k"), + D(s16vector_ref)); + + + m.def("u32vector_ref", + &::pmt::u32vector_ref, + py::arg("v"), + py::arg("k"), + D(u32vector_ref)); + + + m.def("s32vector_ref", + &::pmt::s32vector_ref, + py::arg("v"), + py::arg("k"), + D(s32vector_ref)); + + + m.def("u64vector_ref", + &::pmt::u64vector_ref, + py::arg("v"), + py::arg("k"), + D(u64vector_ref)); + + + m.def("s64vector_ref", + &::pmt::s64vector_ref, + py::arg("v"), + py::arg("k"), + D(s64vector_ref)); + + + m.def("f32vector_ref", + &::pmt::f32vector_ref, + py::arg("v"), + py::arg("k"), + D(f32vector_ref)); + + + m.def("f64vector_ref", + &::pmt::f64vector_ref, + py::arg("v"), + py::arg("k"), + D(f64vector_ref)); + + + m.def("c32vector_ref", + &::pmt::c32vector_ref, + py::arg("v"), + py::arg("k"), + D(c32vector_ref)); + + + m.def("c64vector_ref", + &::pmt::c64vector_ref, + py::arg("v"), + py::arg("k"), + D(c64vector_ref)); + + + m.def("u8vector_set", + &::pmt::u8vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(u8vector_set)); + + + m.def("s8vector_set", + &::pmt::s8vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(s8vector_set)); + + + m.def("u16vector_set", + &::pmt::u16vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(u16vector_set)); + + + m.def("s16vector_set", + &::pmt::s16vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(s16vector_set)); + + + m.def("u32vector_set", + &::pmt::u32vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(u32vector_set)); + + + m.def("s32vector_set", + &::pmt::s32vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(s32vector_set)); + + + m.def("u64vector_set", + &::pmt::u64vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(u64vector_set)); + + + m.def("s64vector_set", + &::pmt::s64vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(s64vector_set)); + + + m.def("f32vector_set", + &::pmt::f32vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(f32vector_set)); + + + m.def("f64vector_set", + &::pmt::f64vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(f64vector_set)); + + + m.def("c32vector_set", + &::pmt::c32vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(c32vector_set)); + + + m.def("c64vector_set", + &::pmt::c64vector_set, + py::arg("v"), + py::arg("k"), + py::arg("x"), + D(c64vector_set)); + + + m.def("uniform_vector_elements", + &::pmt::uniform_vector_elements, + py::arg("v"), + py::arg("len"), + D(uniform_vector_elements)); + + + m.def("u8vector_elements", + (uint8_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::u8vector_elements, + py::arg("v"), + py::arg("len"), + D(u8vector_elements, 0)); + + + m.def("s8vector_elements", + (int8_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::s8vector_elements, + py::arg("v"), + py::arg("len"), + D(s8vector_elements, 0)); + + + m.def("u16vector_elements", + (uint16_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::u16vector_elements, + py::arg("v"), + py::arg("len"), + D(u16vector_elements, 0)); + + + m.def("s16vector_elements", + (int16_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::s16vector_elements, + py::arg("v"), + py::arg("len"), + D(s16vector_elements, 0)); + + + m.def("u32vector_elements", + (uint32_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::u32vector_elements, + py::arg("v"), + py::arg("len"), + D(u32vector_elements, 0)); + + + m.def("s32vector_elements", + (int32_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::s32vector_elements, + py::arg("v"), + py::arg("len"), + D(s32vector_elements, 0)); + + + m.def("u64vector_elements", + (uint64_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::u64vector_elements, + py::arg("v"), + py::arg("len"), + D(u64vector_elements, 0)); + + + m.def("s64vector_elements", + (int64_t const* (*)(pmt::pmt_t, size_t&)) & ::pmt::s64vector_elements, + py::arg("v"), + py::arg("len"), + D(s64vector_elements, 0)); + + + m.def("f32vector_elements", + (float const* (*)(pmt::pmt_t, size_t&)) & ::pmt::f32vector_elements, + py::arg("v"), + py::arg("len"), + D(f32vector_elements, 0)); + + + m.def("f64vector_elements", + (double const* (*)(pmt::pmt_t, size_t&)) & ::pmt::f64vector_elements, + py::arg("v"), + py::arg("len"), + D(f64vector_elements, 0)); + + + m.def("c32vector_elements", + (std::complex<float> const* (*)(pmt::pmt_t, size_t&)) & + ::pmt::c32vector_elements, + py::arg("v"), + py::arg("len"), + D(c32vector_elements, 0)); + + + m.def("c64vector_elements", + (std::complex<double> const* (*)(pmt::pmt_t, size_t&)) & + ::pmt::c64vector_elements, + py::arg("v"), + py::arg("len"), + D(c64vector_elements, 0)); + + m.def("u8vector_elements", + (std::vector<unsigned char, std::allocator<unsigned char>> const (*)( + pmt::pmt_t)) & + ::pmt::u8vector_elements, + py::arg("v"), + D(u8vector_elements, 1)); + + + m.def("s8vector_elements", + (std::vector<signed char, std::allocator<signed char>> const (*)(pmt::pmt_t)) & + ::pmt::s8vector_elements, + py::arg("v"), + D(s8vector_elements, 1)); + + + m.def("u16vector_elements", + (std::vector<unsigned short, std::allocator<unsigned short>> const (*)( + pmt::pmt_t)) & + ::pmt::u16vector_elements, + py::arg("v"), + D(u16vector_elements, 1)); + + + m.def("s16vector_elements", + (std::vector<short, std::allocator<short>> const (*)(pmt::pmt_t)) & + ::pmt::s16vector_elements, + py::arg("v"), + D(s16vector_elements, 1)); + + + m.def( + "u32vector_elements", + (std::vector<unsigned int, std::allocator<unsigned int>> const (*)(pmt::pmt_t)) & + ::pmt::u32vector_elements, + py::arg("v"), + D(u32vector_elements, 1)); + + + m.def("s32vector_elements", + (std::vector<int, std::allocator<int>> const (*)(pmt::pmt_t)) & + ::pmt::s32vector_elements, + py::arg("v"), + D(s32vector_elements, 1)); + + + m.def("u64vector_elements", + (std::vector<uint64_t, std::allocator<uint64_t>> const (*)(pmt::pmt_t)) & + ::pmt::u64vector_elements, + py::arg("v"), + D(u64vector_elements, 1)); + + + m.def("s64vector_elements", + (std::vector<int64_t, std::allocator<int64_t>> const (*)(pmt::pmt_t)) & + ::pmt::s64vector_elements, + py::arg("v"), + D(s64vector_elements, 1)); + + + m.def("f32vector_elements", + (std::vector<float, std::allocator<float>> const (*)(pmt::pmt_t)) & + ::pmt::f32vector_elements, + py::arg("v"), + D(f32vector_elements, 1)); + + + m.def("f64vector_elements", + (std::vector<double, std::allocator<double>> const (*)(pmt::pmt_t)) & + ::pmt::f64vector_elements, + py::arg("v"), + D(f64vector_elements, 1)); + + + m.def( + "c32vector_elements", + (std::vector<std::complex<float>, std::allocator<std::complex<float>>> const (*)( + pmt::pmt_t)) & + ::pmt::c32vector_elements, + py::arg("v"), + D(c32vector_elements, 1)); + + + m.def("c64vector_elements", + (std::vector<std::complex<double>, + std::allocator<std::complex<double>>> const (*)(pmt::pmt_t)) & + ::pmt::c64vector_elements, + py::arg("v"), + D(c64vector_elements, 1)); + + // The following functions are not implemented in pmt.cc + // m.def("pmt_u8vector_elements",&pmt::pmt_u8vector_elements, + // py::arg("v") + // ); + // m.def("pmt_s8vector_elements",&pmt::pmt_s8vector_elements, + // py::arg("v") + // ); + // m.def("pmt_u16vector_elements",&pmt::pmt_u16vector_elements, + // py::arg("v") + // ); + // m.def("pmt_s16vector_elements",&pmt::pmt_s16vector_elements, + // py::arg("v") + // ); + // m.def("pmt_u32vector_elements",&pmt::pmt_u32vector_elements, + // py::arg("v") + // ); + // m.def("pmt_s32vector_elements",&pmt::pmt_s32vector_elements, + // py::arg("v") + // ); + // m.def("pmt_u64vector_elements",&pmt::pmt_u64vector_elements, + // py::arg("v") + // ); + // m.def("pmt_s64vector_elements",&pmt::pmt_s64vector_elements, + // py::arg("v") + // ); + // m.def("pmt_f32vector_elements",&pmt::pmt_f32vector_elements, + // py::arg("v") + // ); + // m.def("pmt_f64vector_elements",&pmt::pmt_f64vector_elements, + // py::arg("v") + // ); + // m.def("pmt_c32vector_elements",&pmt::pmt_c32vector_elements, + // py::arg("v") + // ); + // m.def("pmt_c64vector_elements",&pmt::pmt_c64vector_elements, + // py::arg("v") + // ); + m.def("uniform_vector_writable_elements", + &::pmt::uniform_vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(uniform_vector_writable_elements)); + + + m.def("u8vector_writable_elements", + &::pmt::u8vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(u8vector_writable_elements)); + + + m.def("s8vector_writable_elements", + &::pmt::s8vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(s8vector_writable_elements)); + + + m.def("u16vector_writable_elements", + &::pmt::u16vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(u16vector_writable_elements)); + + + m.def("s16vector_writable_elements", + &::pmt::s16vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(s16vector_writable_elements)); + + + m.def("u32vector_writable_elements", + &::pmt::u32vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(u32vector_writable_elements)); + + + m.def("s32vector_writable_elements", + &::pmt::s32vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(s32vector_writable_elements)); + + + m.def("u64vector_writable_elements", + &::pmt::u64vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(u64vector_writable_elements)); + + + m.def("s64vector_writable_elements", + &::pmt::s64vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(s64vector_writable_elements)); + + + m.def("f32vector_writable_elements", + &::pmt::f32vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(f32vector_writable_elements)); + + + m.def("f64vector_writable_elements", + &::pmt::f64vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(f64vector_writable_elements)); + + + m.def("c32vector_writable_elements", + &::pmt::c32vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(c32vector_writable_elements)); + + + m.def("c64vector_writable_elements", + &::pmt::c64vector_writable_elements, + py::arg("v"), + py::arg("len"), + D(c64vector_writable_elements)); + + + m.def("is_dict", &::pmt::is_dict, py::arg("obj"), D(is_dict)); + + + m.def("make_dict", &::pmt::make_dict, D(make_dict)); + + + m.def("dict_add", + &::pmt::dict_add, + py::arg("dict"), + py::arg("key"), + py::arg("value"), + D(dict_add)); + + + m.def("dict_delete", + &::pmt::dict_delete, + py::arg("dict"), + py::arg("key"), + D(dict_delete)); + + + m.def("dict_has_key", + &::pmt::dict_has_key, + py::arg("dict"), + py::arg("key"), + D(dict_has_key)); + + + m.def("dict_ref", + &::pmt::dict_ref, + py::arg("dict"), + py::arg("key"), + py::arg("not_found"), + D(dict_ref)); + + + m.def("dict_items", &::pmt::dict_items, py::arg("dict"), D(dict_items)); + + + m.def("dict_keys", &::pmt::dict_keys, py::arg("dict"), D(dict_keys)); + + + m.def("dict_update", + &::pmt::dict_update, + py::arg("dict1"), + py::arg("dict2"), + D(dict_update)); + + + m.def("dict_values", &::pmt::dict_values, py::arg("dict"), D(dict_values)); + + + m.def("is_any", &::pmt::is_any, py::arg("obj"), D(is_any)); + + + m.def("make_any", &::pmt::make_any, py::arg("any"), D(make_any)); + + + m.def("any_ref", &::pmt::any_ref, py::arg("obj"), D(any_ref)); + + + m.def("any_set", &::pmt::any_set, py::arg("obj"), py::arg("any"), D(any_set)); + + // m.def("is_msg_accepter",&pmt::is_msg_accepter, + // py::arg("obj") + // ); + // m.def("make_msg_accepter",&pmt::make_msg_accepter, + // py::arg("ma") + // ); + // m.def("msg_accepter_ref",&pmt::msg_accepter_ref, + // py::arg("obj") + // ); + m.def("is_pdu", &::pmt::is_pdu, py::arg("obj"), D(is_pdu)); + + + m.def("eq", &::pmt::eq, py::arg("x"), py::arg("y"), D(eq)); + + + m.def("eqv", &::pmt::eqv, py::arg("x"), py::arg("y"), D(eqv)); + + + m.def("equal", &::pmt::equal, py::arg("x"), py::arg("y"), D(equal)); + + + m.def("assq", &::pmt::assq, py::arg("obj"), py::arg("alist"), D(assq)); + + + m.def("assv", &::pmt::assv, py::arg("obj"), py::arg("alist"), D(assv)); + + + m.def("assoc", &::pmt::assoc, py::arg("obj"), py::arg("alist"), D(assoc)); + + + m.def("map", &::pmt::map, py::arg("proc"), py::arg("list"), D(map)); + + + m.def("reverse", &::pmt::reverse, py::arg("list"), D(reverse)); + + + m.def("reverse_x", &::pmt::reverse_x, py::arg("list"), D(reverse_x)); + + + m.def("acons", &::pmt::acons, py::arg("x"), py::arg("y"), py::arg("a"), D(acons)); + + + m.def("nth", &::pmt::nth, py::arg("n"), py::arg("list"), D(nth)); + + + m.def("nthcdr", &::pmt::nthcdr, py::arg("n"), py::arg("list"), D(nthcdr)); + + + m.def("memq", &::pmt::memq, py::arg("obj"), py::arg("list"), D(memq)); + + + m.def("memv", &::pmt::memv, py::arg("obj"), py::arg("list"), D(memv)); + + + m.def("member", &::pmt::member, py::arg("obj"), py::arg("list"), D(member)); + + + m.def("subsetp", &::pmt::subsetp, py::arg("list1"), py::arg("list2"), D(subsetp)); + + + m.def("list1", &::pmt::list1, py::arg("x1"), D(list1)); + + + m.def("list2", &::pmt::list2, py::arg("x1"), py::arg("x2"), D(list2)); + + + m.def("list3", &::pmt::list3, py::arg("x1"), py::arg("x2"), py::arg("x3"), D(list3)); + + + m.def("list4", + &::pmt::list4, + py::arg("x1"), + py::arg("x2"), + py::arg("x3"), + py::arg("x4"), + D(list4)); + + + m.def("list5", + &::pmt::list5, + py::arg("x1"), + py::arg("x2"), + py::arg("x3"), + py::arg("x4"), + py::arg("x5"), + D(list5)); + + + m.def("list6", + &::pmt::list6, + py::arg("x1"), + py::arg("x2"), + py::arg("x3"), + py::arg("x4"), + py::arg("x5"), + py::arg("x6"), + D(list6)); + + + m.def("list_add", &::pmt::list_add, py::arg("list"), py::arg("item"), D(list_add)); + + + m.def("list_rm", &::pmt::list_rm, py::arg("list"), py::arg("item"), D(list_rm)); + + + m.def("list_has", &::pmt::list_has, py::arg("list"), py::arg("item"), D(list_has)); + + + m.def("is_eof_object", &::pmt::is_eof_object, py::arg("obj"), D(is_eof_object)); + + + m.def("read", &::pmt::read, py::arg("port"), D(read)); + + + m.def("write", &::pmt::write, py::arg("obj"), py::arg("port"), D(write)); + + + m.def("write_string", &::pmt::write_string, py::arg("obj"), D(write_string)); + + + m.def("print", &::pmt::print, py::arg("v"), D(print)); + + + m.def("serialize", &::pmt::serialize, py::arg("obj"), py::arg("sink"), D(serialize)); + + + m.def("deserialize", &::pmt::deserialize, py::arg("source"), D(deserialize)); + + + m.def("dump_sizeof", &::pmt::dump_sizeof, D(dump_sizeof)); + + m.def("length", &pmt::length, py::arg("v")); + + // pybind11 needs explicit conversion to handle non-utf8 strings + m.def( + "serialize_str", + [](pmt::pmt_t obj) { + std::string s = serialize_str(obj); + return py::bytes(s); // Return the data without transcoding + }, + py::arg("obj"), + D(serialize_str)); + + m.def("deserialize_str", &pmt::deserialize_str, py::arg("str"), D(deserialize_str)); +} diff --git a/gnuradio-runtime/python/pmt/bindings/pmt_sugar_python.cc b/gnuradio-runtime/python/pmt/bindings/pmt_sugar_python.cc new file mode 100644 index 0000000000..442d00369f --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/pmt_sugar_python.cc @@ -0,0 +1,217 @@ +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +/* This file is automatically generated using bindtool */ + +#include <pybind11/complex.h> +#include <pybind11/pybind11.h> +#include <pybind11/stl.h> + +namespace py = pybind11; + +#include <pmt/pmt_sugar.h> +// pydoc.h is automatically generated in the build directory +#include <pmt_sugar_pydoc.h> + +void bind_pmt_sugar(py::module& m) +{ + m.def("mp", (pmt::pmt_t(*)(std::string const&)) & ::pmt::mp, py::arg("s"), D(mp, 0)); + + + m.def("mp", (pmt::pmt_t(*)(char const*)) & ::pmt::mp, py::arg("s"), D(mp, 1)); + + + m.def("mp", (pmt::pmt_t(*)(long int)) & ::pmt::mp, py::arg("x"), D(mp, 2)); + + + m.def("mp", (pmt::pmt_t(*)(long unsigned int)) & ::pmt::mp, py::arg("x"), D(mp, 3)); + + + m.def("mp", + (pmt::pmt_t(*)(long long unsigned int)) & ::pmt::mp, + py::arg("x"), + D(mp, 4)); + + + m.def("mp", (pmt::pmt_t(*)(int)) & ::pmt::mp, py::arg("x"), D(mp, 5)); + + + m.def("mp", (pmt::pmt_t(*)(double)) & ::pmt::mp, py::arg("x"), D(mp, 6)); + + + m.def( + "mp", (pmt::pmt_t(*)(std::complex<double>)) & ::pmt::mp, py::arg("z"), D(mp, 7)); + + + m.def("mp", (pmt::pmt_t(*)(std::complex<float>)) & ::pmt::mp, py::arg("z"), D(mp, 8)); + + + // m.def("mp", + // (pmt::pmt_t(*)(std::shared_ptr<gr::messages::msg_accepter>)) & ::pmt::mp, + // py::arg("ma"), + // D(mp, 9)); + + + m.def("mp", + (pmt::pmt_t(*)(void const*, size_t)) & ::pmt::mp, + py::arg("data"), + py::arg("len_in_bytes"), + D(mp, 10)); + + + m.def("mp", (pmt::pmt_t(*)(pmt::pmt_t const&)) & ::pmt::mp, py::arg("e0"), D(mp, 11)); + + + m.def("mp", + (pmt::pmt_t(*)(pmt::pmt_t const&, pmt::pmt_t const&)) & ::pmt::mp, + py::arg("e0"), + py::arg("e1"), + D(mp, 12)); + + + m.def("mp", + (pmt::pmt_t(*)(pmt::pmt_t const&, pmt::pmt_t const&, pmt::pmt_t const&)) & + ::pmt::mp, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + D(mp, 13)); + + + m.def( + "mp", + (pmt::pmt_t(*)( + pmt::pmt_t const&, pmt::pmt_t const&, pmt::pmt_t const&, pmt::pmt_t const&)) & + ::pmt::mp, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + D(mp, 14)); + + + m.def("mp", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::mp, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + D(mp, 15)); + + + m.def("mp", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::mp, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + D(mp, 16)); + + + m.def("mp", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::mp, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + py::arg("e6"), + D(mp, 17)); + + + m.def("mp", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::mp, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + py::arg("e6"), + py::arg("e7"), + D(mp, 18)); + + + m.def("mp", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::mp, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + py::arg("e6"), + py::arg("e7"), + py::arg("e8"), + D(mp, 19)); + + + m.def("mp", + (pmt::pmt_t(*)(pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&, + pmt::pmt_t const&)) & + ::pmt::mp, + py::arg("e0"), + py::arg("e1"), + py::arg("e2"), + py::arg("e3"), + py::arg("e4"), + py::arg("e5"), + py::arg("e6"), + py::arg("e7"), + py::arg("e8"), + py::arg("e9"), + D(mp, 20)); +} diff --git a/gnuradio-runtime/python/pmt/bindings/python_bindings.cc b/gnuradio-runtime/python/pmt/bindings/python_bindings.cc new file mode 100644 index 0000000000..af312f5802 --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/python_bindings.cc @@ -0,0 +1,46 @@ + +/* + * Copyright 2020 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * SPDX-License-Identifier: GPL-3.0-or-later + * + */ + +#include <pybind11/pybind11.h> + +#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION +#include <numpy/arrayobject.h> + +namespace py = pybind11; + +void bind_pmt(py::module&); +void bind_pmt_pool(py::module&); +// void bind_pmt_serial_tags(py::module&); +void bind_pmt_sugar(py::module&); + +// We need this hack because import_array() returns NULL +// for newer Python versions. +// This function is also necessary because it ensures access to the C API +// and removes a warning. +void* init_numpy() +{ + import_array(); + return NULL; +} + +PYBIND11_MODULE(pmt_python, m) +{ + // Initialize the numpy C API + // (otherwise we will see segmentation faults) + init_numpy(); + + // Allow access to base block methods + // py::module::import("gnuradio.gr"); + + bind_pmt(m); + bind_pmt_pool(m); + // bind_pmt_serial_tags(m); + bind_pmt_sugar(m); +} diff --git a/gnuradio-runtime/python/pmt/pmt_to_python.py b/gnuradio-runtime/python/pmt/pmt_to_python.py index 1c547ba521..425d68b6d1 100644 --- a/gnuradio-runtime/python/pmt/pmt_to_python.py +++ b/gnuradio-runtime/python/pmt/pmt_to_python.py @@ -7,7 +7,7 @@ from __future__ import unicode_literals -from . import pmt_swig as pmt +from . import pmt_python as pmt import numpy # SWIG isn't taking in the #define PMT_NIL; @@ -112,7 +112,7 @@ def pmt_to_python(p): if pmt_check(p): try: return to_python(p) - except (TypeError, ValueError): + except (RuntimeError, TypeError, ValueError): # TODO: make pybind11 handle wrong_type, convert to type error # This exception will be handled by the general failure case pass raise ValueError("can't convert %s type to pmt (%s)"%(type(p),p)) |