Add "call_guards" option

Author: gen740

README.md

@@ -89,6 +89,10 @@ Parser compile options.
 **libclang_path** [path, optional]
 Path to `libclang` shared library.
 
+**call_guards** [array of string, optional]
+Add call_guard to exported function and member function, this option is
+useful when you want to add some call_guard to all C++ function.
+
 **include_headers** [array of filename, optional]
 **deprecated** `cppygen` does not resolve include paths, thus if you want to export C++
 classes you should specify include filenames.

cppygen/__main__.py

@@ -70,20 +70,23 @@ def run():
         verbose=args.verbose,
     )
 
-    flags = configs.get("flags") or []
+    for i in configs.get("call_guards", []):
+        cppygen.add_call_guard(i)
 
-    for i in configs.get("include_directories") or []:
+    flags = configs.get("flags", [])
+
+    for i in configs.get("include_directories", []):
         flags.append(f"-I{str(cwd.joinpath(i).absolute())}")
 
     flags.extend([i for i in (args.flags or "").split(";")])
     flags.extend([f"-I{i}" for i in (args.include_directories or "").split(";")])
 
     if mode == "source":
         for i in sources:
-            cppygen.parse_from_file(i, lang="cpp", flags=configs.get("flags") or [])
+            cppygen.parse_from_file(i, lang="cpp", flags=configs.get("flags", []))
 
         for i in headers:
-            cppygen.parse_from_file(i, lang="hpp", flags=configs.get("flags") or [])
+            cppygen.parse_from_file(i, lang="hpp", flags=configs.get("flags", []))
     else:
         cppygen.parse(
             source="\n".join([f"#include<{i}>" for i in headers]),

cppygen/component.py

@@ -16,6 +16,7 @@ def __init__(self):
         self._description = ""
         self._module: str | None = None
         self._pyname: str | None = None
+        self._call_guards: List[str] = []
 
     def set_name(self, name: str, namespace: List[str]):
         self._name = name
@@ -25,6 +26,9 @@ def set_name(self, name: str, namespace: List[str]):
     def set_return_type(self, type: str):
         self._return_type = type
 
+    def add_call_guard(self, call_guard: str):
+        self._call_guards.append(call_guard)
+
     def set_argument_types(self, types: List[Tuple[str, str]]):
         """
         parameter: [(name, type),]
@@ -62,12 +66,12 @@ def to_pybind_string(self, overloaded=False):
                 f'{self._module}.def("{self._pyname}", '
                 f'static_cast<{self._return_type} (*)({", ".join([i[1] for i in self._arguments])})>'
                 f'(&{self._full_name}), "{self._description}"'
-                f'{"".join(args)});'
+                f"""{"".join(args)}{f", pybind11::call_guard<{', '.join(self._call_guards)}>()" if len(self._call_guards) > 0 else ""});"""
             )
         else:
             return (
                 f'{self._module}.def("{self._pyname}", &{self._full_name}, "{self._description}"'
-                f'{"".join(args)});'
+                f"""{"".join(args)}{f", pybind11::call_guard<{', '.join(self._call_guards)}>()" if len(self._call_guards) > 0 else ""});"""
             )
 
     def to_decl_string(self):
@@ -105,8 +109,9 @@ class MemberFunctionSignature(TypedDict):
         name: str
         pyname: str
         return_type: str
-        description: str
         args: List[Tuple[str, str]]
+        description: str
+        call_guards: List[str]
 
     def __init__(self):
         self._name: str | None = None
@@ -141,9 +146,10 @@ def add_member_func(
         self,
         name: str,
         pyname: str | None,
-        type: str,
+        return_type: str,
         args: List[Tuple[str, str]],  # list[(name, type)]
         description: str = "",
+        call_guards: List[str] = [],
         private: bool = False,
     ):
         pyname = pyname or name
@@ -152,9 +158,10 @@ def add_member_func(
                 {
                     "name": name,
                     "pyname": pyname,
-                    "return_type": type,
-                    "description": description,
+                    "return_type": return_type,
                     "args": args,
+                    "description": description,
+                    "call_guards": call_guards,
                 }
             )
 
@@ -193,11 +200,13 @@ def to_pybind_string(self):
                     # overloaded funciton
                     f'\t\t.def("{i["pyname"]}", '
                     f'static_cast<{i["return_type"]} ({self._full_name}::*)({", ".join([j[1] for j in i["args"]])})>'
-                    f'(&{self._full_name}::{i["name"]}), "{i["description"]}")'
+                    f'(&{self._full_name}::{i["name"]}), "{i["description"]}"'
+                    f"""{f", pybind11::call_guard<{', '.join(i['call_guards'])}>()" if len(i['call_guards']) > 0 else ""})"""
                     if [j["name"] for j in self._member_funcs].count(i["name"]) > 1
                     # Non overloaded funciton
                     else f'\t\t.def("{i["pyname"]}",'
-                    f' &{self._full_name}::{i["name"]}, "{i["description"]}")'
+                    f' &{self._full_name}::{i["name"]}, "{i["description"]}"'
+                    f"""{f", pybind11::call_guard<{', '.join(i['call_guards'])}>()" if len(i['call_guards']) > 0 else ""})"""
                     for i in self._member_funcs
                 ]
             )

cppygen/cppygen_parser.py

@@ -29,7 +29,8 @@ def __init__(
         self._structs_and_classes: List[StructOrClass] = []
         self._hpp_includes: List[str] = []
         self._namespace = namespace or "cppygen"
-        self.verbose = verbose
+        self._verbose = verbose
+        self._call_guards: List[str] = []
 
         if library_file != None and library_path != None:
             raise ValueError(f"Both library_path and library_file cannot be set.")
@@ -76,6 +77,8 @@ def _extract_functions(
                 func.set_return_type(i.result_type.spelling)
                 func.set_name(i.spelling, namespace)
                 func.set_module(module_name)
+                for call_guard in self._call_guards:
+                    func.add_call_guard(call_guard)
 
                 # extract comment string
                 raw_comment = i.raw_comment or ""
@@ -90,7 +93,7 @@ def _extract_functions(
                     j: Cursor
                     if j.kind == CursorKind.PARM_DECL:  # type: ignore
                         func.add_argument_type((j.spelling, j.type.spelling))
-                if self.verbose:
+                if self._verbose:
                     print("\t| Function  | " + func.signature())
                 if not func in self._functions:
                     self._functions.append(func)
@@ -125,20 +128,24 @@ def _extract_struct_and_class(
                             j.raw_comment or ""
                         )
                         struct_or_class.add_member_func(
-                            j.spelling,
-                            pyname,
-                            j.result_type.spelling,
-                            args,
-                            description or "",
-                            j.access_specifier == AccessSpecifier.PRIVATE,  # type: ignore
+                            name=j.spelling,
+                            pyname=pyname,
+                            return_type=j.result_type.spelling,
+                            args=args,
+                            description=description or "",
+                            call_guards=self._call_guards,
+                            private=j.access_specifier == AccessSpecifier.PRIVATE,  # type: ignore
                         )
-                if self.verbose:
+                if self._verbose:
                     print("\t| Class     | " + struct_or_class.signature())
                 self._structs_and_classes.append(struct_or_class)
 
     def add_hpp_includes(self, hpp: str):
         self._hpp_includes.append(hpp)
 
+    def add_call_guard(self, call_guard: str):
+        self._call_guards.append(call_guard)
+
     def parse(
         self,
         source: str,
@@ -184,7 +191,7 @@ def visit(x: Cursor, namespace: List[str], module_name: str):
                         submod.set_description(i.brief_comment or "")
                         submod.set_parent(copy.deepcopy(namespace_in))
                         if not submod in self._submodules:
-                            if self.verbose:
+                            if self._verbose:
                                 print(f"\t| Submodule | {submod.cpp_name}")
                             self._submodules.append(submod)
                         namespace_in.append(i.spelling)

tests/test_components.py

@@ -37,6 +37,20 @@ def test_function():
         """(&Shell::foo::test_function1), "this is test function1", pybind11::arg("arg1"), pybind11::arg("arg2"));"""
     )
 
+    fun.add_call_guard("int")
+
+    assert fun.to_pybind_string(overloaded=True) == (
+        """Shell_foo.def("__str__", static_cast<TestClass (*)(int, std::string)>"""
+        """(&Shell::foo::test_function1), "this is test function1", pybind11::arg("arg1"), pybind11::arg("arg2"), pybind11::call_guard<int>());"""
+    )
+
+    fun.add_call_guard("hoge")
+
+    assert fun.to_pybind_string(overloaded=True) == (
+        """Shell_foo.def("__str__", static_cast<TestClass (*)(int, std::string)>"""
+        """(&Shell::foo::test_function1), "this is test function1", pybind11::arg("arg1"), pybind11::arg("arg2"), pybind11::call_guard<int, hoge>());"""
+    )
+
     assert (
         fun.signature()
         == """Shell::foo::test_function1(int, std::string) -> TestClass"""
@@ -103,6 +117,7 @@ def test_struct_or_class():
         "char",
         [("arg1", "bool")],
         "this is the member2(overloaded)",
+        ["int", "bool"],
     )
 
     expect_members = [
@@ -125,20 +140,23 @@ def test_struct_or_class():
             "pyname": "mfun1",
             "return_type": "int",
             "description": "this is the member1",
+            "call_guards": [],
             "args": [("arg1", "int"), ("arg2", "std::string")],
         },
         {
             "name": "mfun2",
             "pyname": "mfun2",
             "return_type": "char",
             "description": "this is the member2",
+            "call_guards": [],
             "args": [("arg1", "std::string"), ("arg2", "std::vector<int>")],
         },
         {
             "name": "mfun2",
             "pyname": "mfun2",
             "return_type": "char",
             "description": "this is the member2(overloaded)",
+            "call_guards": ["int", "bool"],
             "args": [("arg1", "bool")],
         },
     ]
@@ -151,6 +169,6 @@ def test_struct_or_class():
         """\t\t.def_readwrite("member2", &mod1::mod2::class1::member2, "this is the member2")\n"""
         """\t\t.def("mfun1", &mod1::mod2::class1::mfun1, "this is the member1")\n"""
         """\t\t.def("mfun2", static_cast<char (mod1::mod2::class1::*)(std::string, std::vector<int>)>(&mod1::mod2::class1::mfun2), "this is the member2")\n"""
-        """\t\t.def("mfun2", static_cast<char (mod1::mod2::class1::*)(bool)>(&mod1::mod2::class1::mfun2), "this is the member2(overloaded)");"""
+        """\t\t.def("mfun2", static_cast<char (mod1::mod2::class1::*)(bool)>(&mod1::mod2::class1::mfun2), "this is the member2(overloaded)", pybind11::call_guard<int, bool>());"""
     )
     assert soc.to_pybind_string() == expect_pybind_string