diff options
| author | Josh Morman <mormjb@gmail.com> | 2020-04-23 07:12:36 -0400 |
|---|---|---|
| committer | Josh Morman <mormjb@gmail.com> | 2020-06-04 10:05:47 -0400 |
| commit | 088d2c4fec5b2726ee3085cd84bf9502a25927a3 (patch) | |
| tree | 873fef7b5e655e267b3fdbe652a8901ea40adc89 /gnuradio-runtime/python | |
| parent | 9d3c5a133c49a8bba778568fb30c1f3afe577f4c (diff) | |
pmt: add pybind11 bindings
Diffstat (limited to 'gnuradio-runtime/python')
11 files changed, 2864 insertions, 7 deletions
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..76d7234d14 --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/docstrings/pmt_pydoc_template.h @@ -0,0 +1,876 @@ +/* + * 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_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_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..eb9b0e1a43 --- /dev/null +++ b/gnuradio-runtime/python/pmt/bindings/pmt_python.cc @@ -0,0 +1,1553 @@ +/* + * 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("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<unsigned long, std::allocator<unsigned long>> 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<long, std::allocator<long>> 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<unsigned long, std::allocator<unsigned long>> const (*)( + pmt::pmt_t)) & + ::pmt::u64vector_elements, + py::arg("v"), + D(u64vector_elements, 1)); + + + m.def("s64vector_elements", + (std::vector<long, std::allocator<long>> 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("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)) |