Add --block option to interface generators

igo95862 · igo95862 · commit 8af9ea305abf · 2023-10-28T23:36:05.000+06:00
Generates blocking interfaces code when passed instead of
async.
diff --git a/docs/code_generator.rst b/docs/code_generator.rst
@@ -3,7 +3,8 @@ Interface code generator
 
 Python-sdbus is able to generate the interfaces code from
 the D-Bus introspection XML. (either from a file or live object on D-Bus)
-Currently only async interfaces code can be generated.
+Currently async interfaces code is generated by default.
+Blocking interfaces can be generated by passing ``--block`` option.
 
 Running code generator requires
 `Jinja2 <https://jinja2docs.readthedocs.io/en/stable/>`_
diff --git a/src/sdbus/__main__.py b/src/sdbus/__main__.py
@@ -26,7 +26,7 @@
 
 from .interface_generator import (
     DbusInterfaceIntrospection,
-    generate_async_py_file,
+    generate_py_file,
     interfaces_from_file,
     interfaces_from_str,
 )
@@ -37,6 +37,7 @@ def run_gen_from_connection(
     object_paths: List[str],
     system: bool,
     imports_header: bool,
+    do_async: bool,
 ) -> None:
     connection_name = connection_name
     object_paths = object_paths
@@ -55,19 +56,31 @@ def run_gen_from_connection(
         interfaces.extend(interfaces_from_str(itrospection))
 
     stdout.write(
-        generate_async_py_file(
-            interfaces, imports_header))
+        generate_py_file(
+            interfaces,
+            imports_header,
+            do_async,
+        )
+    )
 
 
-def run_gen_from_file(filenames: List[str], imports_header: bool) -> None:
+def run_gen_from_file(
+    filenames: List[str],
+    imports_header: bool,
+    do_async: bool,
+) -> None:
     interfaces: List[DbusInterfaceIntrospection] = []
 
     for file in filenames:
         interfaces.extend(interfaces_from_file(file))
 
     stdout.write(
-        generate_async_py_file(
-            interfaces, imports_header))
+        generate_py_file(
+            interfaces,
+            imports_header,
+            do_async,
+        )
+    )
 
 
 def generator_main(args: Optional[List[str]] = None) -> None:
@@ -94,6 +107,17 @@ def generator_main(args: Optional[List[str]] = None) -> None:
             help="Include 'import' header (default)",
         )
 
+        subparser.add_argument(
+            "--async", action="store_true", default=True,
+            dest="do_async",
+            help="Generate async interfaces (default)",
+        )
+        subparser.add_argument(
+            "--block", action="store_false",
+            dest="do_async",
+            help="Generate blocking interfaces",
+        )
+
     generate_from_file_parser.add_argument(
         'filenames', type=Path, nargs='+',
         help="Paths to interface XML introspection files"
diff --git a/src/sdbus/interface_generator.py b/src/sdbus/interface_generator.py
@@ -549,6 +549,32 @@ def __init__(self, element: Element):
 }
 
 INTERFACE_TEMPLATES: Dict[str, str] = {
+    "generic_method_flags": (
+        r"""
+{%- if method.dbus_input_signature %}
+input_signature="{{ method.dbus_input_signature }}",
+{%- endif %}
+
+{%- if method.dbus_result_signature %}
+result_signature="{{ method.dbus_result_signature }}",
+{%- endif %}
+
+{%- if method.flags_str %}
+flags={{ method.flags_str }},
+{%- endif %}
+"""
+    ),
+    "generic_property_flags": (
+        r"""
+{%- if a_property.dbus_signature %}
+property_signature="{{ a_property.dbus_signature }}",
+{%- endif %}
+
+{%- if a_property.flags_str %}
+flags={{ a_property.flags_str }},
+{%- endif %}
+"""
+    ),
     "generic_header": r"""from __future__ import annotations
 
 from typing import Any, Dict, List, Tuple""",
@@ -598,18 +624,9 @@ def __init__(self, element: Element):
     "async_method": (
         r"""
 @dbus_method_async(
-
-{%- if method.dbus_input_signature %}
-    input_signature="{{ method.dbus_input_signature }}",
-{%- endif %}
-
-{%- if method.dbus_result_signature %}
-    result_signature="{{ method.dbus_result_signature }}",
-{%- endif %}
-
-{%- if method.flags_str %}
-    flags={{ method.flags_str }},
-{%- endif %}
+{%- filter indent -%}
+{%- include 'generic_method_flags' -%}
+{%- endfilter %}
 )
 async def {{ method.python_name }}(
     self,
@@ -624,14 +641,9 @@ async def {{ method.python_name }}(
     "async_property": (
         r"""
 @dbus_property_async(
-
-{%- if a_property.dbus_signature %}
-    property_signature="{{ a_property.dbus_signature }}",
-{%- endif %}
-
-{%- if a_property.flags_str %}
-    flags={{ a_property.flags_str }},
-{%- endif %}
+{%- filter indent -%}
+{%- include 'generic_property_flags' -%}
+{%- endfilter %}
 )
 def {{ a_property.python_name }}(self) -> {{ a_property.typing }}:
     raise NotImplementedError"""
@@ -651,6 +663,72 @@ def {{ a_property.python_name }}(self) -> {{ a_property.typing }}:
 def {{ signal.python_name }}(self) -> {{ signal.typing }}:
     raise NotImplementedError"""
     ),
+    "blocking_imports_header": r"""from sdbus import (
+    DbusDeprecatedFlag,
+    DbusInterfaceCommon,
+    DbusNoReplyFlag,
+    DbusPropertyConstFlag,
+    DbusPropertyEmitsChangeFlag,
+    DbusPropertyEmitsInvalidationFlag,
+    DbusPropertyExplicitFlag,
+    DbusUnprivilegedFlag,
+    dbus_method,
+    dbus_property,
+)""",
+    "blocking_main": (
+        r"""{% if include_import_header -%}
+{% include 'generic_header' %}
+
+{% include 'blocking_imports_header' %}
+{%- endif %}
+{% for interface in interfaces %}
+
+{% include 'blocking_interface' %}
+{%- endfor %}
+"""
+    ),
+    "blocking_interface": (
+        r"""class {{ interface.python_name }}(
+    DbusInterfaceCommon,
+    interface_name="{{ interface.interface_name }}",
+):
+{%- filter indent -%}
+{% for method in interface.methods -%}
+{% include 'blocking_method' %}
+{% endfor -%}
+{% for a_property in interface.properties -%}
+{% include 'blocking_property' %}
+{% endfor -%}
+{%- endfilter -%}
+"""
+    ),
+    "blocking_method": (
+        r"""
+@dbus_method(
+{%- filter indent -%}
+{%- include 'generic_method_flags' -%}
+{%- endfilter %}
+)
+def {{ method.python_name }}(
+    self,
+
+{%- for arg_name, arg_type in method.args_names_and_typing %}
+    {{ arg_name }}: {{ arg_type }},
+{%- endfor %}
+) -> {{ method.result_typing }}:
+    raise NotImplementedError
+"""
+    ),
+    "blocking_property": (
+        r"""
+@dbus_property(
+{%- filter indent -%}
+{%- include 'generic_property_flags' -%}
+{%- endfilter %}
+)
+def {{ a_property.python_name }}(self) -> {{ a_property.typing }}:
+    raise NotImplementedError"""
+    ),
 }
 
 
@@ -690,15 +768,19 @@ def interfaces_from_str(xml_str: str) -> List[DbusInterfaceIntrospection]:
     return xml_to_interfaces_introspection(etree)
 
 
-def generate_async_py_file(
-        interfaces: List[DbusInterfaceIntrospection],
-        include_import_header: bool = True) -> str:
+def generate_py_file(
+    interfaces: List[DbusInterfaceIntrospection],
+    include_import_header: bool = True,
+    do_async: bool = True,
+) -> str:
 
     from jinja2 import DictLoader
     from jinja2 import Environment as JinjaEnv
 
+    template_name = "async_main" if do_async else "blocking_main"
+
     env = JinjaEnv(loader=DictLoader(INTERFACE_TEMPLATES))
-    return env.get_template("async_main").render(
+    return env.get_template(template_name).render(
         interfaces=interfaces,
         include_import_header=include_import_header,
     )
diff --git a/test/test_interface_generator.py b/test/test_interface_generator.py
@@ -27,7 +27,7 @@
 from sdbus.interface_generator import (
     DbusSigToTyping,
     camel_case_to_snake_case,
-    generate_async_py_file,
+    generate_py_file,
     interface_name_to_class,
     interfaces_from_str,
 )
@@ -196,7 +196,7 @@ def test_parsing(self) -> None:
                         False,
                     )
 
-        generated = generate_async_py_file(interfaces_intro)
+        generated = generate_py_file(interfaces_intro)
         self.assertIn('flags=DbusPropertyEmitsInvalidationFlag', generated)
         self.assertIn('flags=DbusPropertyConstFlag', generated)
 
@@ -228,6 +228,38 @@ def test_generate_from_connection(self) -> None:
             "get_connection_unix_process_id",
             generated_interface,
         )
+        self.assertIn(
+            "async",
+            generated_interface,
+        )
+
+    def test_generate_from_connection_blocking(self) -> None:
+        if find_spec('jinja2') is None:
+            raise SkipTest('Jinja2 not installed')
+
+        with patch("sdbus.__main__.stdout") as stdout_mock:
+            generator_main(
+                [
+                    "gen-from-connection",
+                    "--block",
+                    "org.freedesktop.DBus",
+                    "/org/freedesktop/DBus",
+                ]
+            )
+
+        write_mock: MagicMock = stdout_mock.write
+        write_mock.assert_called_once()
+
+        generated_interface = write_mock.call_args.args[0]
+
+        self.assertNotIn(
+            "async",
+            generated_interface,
+        )
+        self.assertIn(
+            "dbus_property",
+            generated_interface,
+        )
 
 
 if __name__ == "__main__":
