Latest update of the code-generation tool for settings-dataclasses.

Not perfect yet, but the most common cases shoult be covered now.
It needs the man/nm-settings-docs-dbus.xml from a build of NM.

It can be improved to the point where the settings sub-package is
fully generated.

Author: Bernhard Kaindl

tools/generate-settings-dataclasses.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python
+# SPDX-License-Identifier: LGPL-2.1-or-later
+import collections
+from typing import Any, Dict, List, OrderedDict, Optional, Tuple
+import xml.etree.ElementTree as ElementTree
+import textwrap
+
+
+def dbg(msg: Any) -> None:
+    print(f"{msg}")
+
+
+def write(msg: Any) -> None:
+    print(f"{msg}")
+
+
+dbus_type_name_map = {
+    "b": "bool",
+    "s": "str",
+    "i": "int",
+    "u": "int",
+    "t": "int",
+    "x": "int",
+    "y": "Byte",
+    "as": "List[str]",
+    "au": "List[int]",
+    "ay": "bytes",
+    "a{ss}": "Dict[str, str]",
+    "a{sv}": "vardict",
+    "aa{sv}": "List[Tuple[str, Any]]",
+    "aau": "List[List[int]]",
+    "aay": "List[bytes]",
+    # Legacy types:
+    "a(ayuay)": "array of legacy IPv6 address struct",
+    "a(ayuayu)": "array of legacy IPv6 route struct",
+}
+dbus_name_type_map = {
+    'array of array of uint32': 'aau',
+    'array of byte array': 'aay',
+    'array of legacy IPv6 address struct': 'a(ayuay)',
+    'array of legacy IPv6 route struct': 'a(ayuayu)',
+    'array of string': 'as',
+    'array of uint32': 'au',
+    'array of vardict': 'aa{sv}',
+    'boolean': 'b',
+    'byte': 'y',
+    'byte array': 'ay',
+    'dict of string to string': 'a{ss}',
+    'int32': 'i',
+    'int64': 'x',
+    'string': 's',
+    'uint32': 'u',
+    'uint64': 't',
+    'vardict': 'a{sv}',
+}
+
+###############################################################################
+
+_setting_name_order = [
+    "connection",
+    "ipv4",
+    "ipv6",
+    "generic",
+    "802-3-ethernet",
+    "802-11-wireless",
+    "802-11-wireless-security",
+    "gsm",
+    "ethtool",
+    "6lowpan",
+    "802-1x",
+    "adsl",
+    "bluetooth",
+    "bond",
+    "bridge",
+    "bridge-port",
+    "cdma",
+    "dcb",
+    "dummy",
+    "infiniband",
+    "ip-tunnel",
+    "macsec",
+    "macvlan",
+    "match",
+    "802-11-olpc-mesh",
+    "ovs-bridge",
+    "ovs-dpdk",
+    "ovs-interface",
+    "ovs-patch",
+    "ovs-port",
+    "ppp",
+    "pppoe",
+    "proxy",
+    "serial",
+    "sriov",
+    "tc",
+    "team",
+    "team-port",
+    "tun",
+    "user",
+    "vlan",
+    "vpn",
+    "vrf",
+    "vxlan",
+    "wifi-p2p",
+    "wimax",
+    "wireguard",
+    "wpan",
+]
+
+
+def _setting_name_order_idx(name: str) -> int:
+    try:
+        return _setting_name_order.index(name)
+    except ValueError:
+        return len(_setting_name_order)
+
+
+def key_fcn_setting_name(n1: str) -> Tuple[int, str]:
+    return (_setting_name_order_idx(n1), n1)
+
+
+def iter_keys_of_dicts(
+    dicts: List[Dict[str, Any]], key: Optional[Any] = None
+) -> List[str]:
+    keys = {k for d in dicts for k in d.keys()}
+    return sorted(keys, key=key)
+
+
+def node_to_dict(node: Any, tag: str, key_attr: str) -> Dict[str, Any]:
+    dictionary = collections.OrderedDict()
+    if node is not None:
+        for n in node.iter(tag):
+            k = n.get(key_attr)
+            assert k is not None
+            dictionary[k] = n
+    return dictionary
+
+
+def node_get_attr(nodes: List[Optional[Any]], name: str) -> Any:
+    for n in nodes:
+        if n is None:
+            continue
+        x = n.get(name, None)
+        if x:
+            return x
+    return None
+
+
+def node_set_attr(
+    dst_node: Any, name: str, nodes: List[Optional[Any]]
+) -> None:
+    x = node_get_attr(nodes, name)
+    if x:
+        dst_node.set(name, x)
+
+
+def find_first_not_none(itr: List[Any]) -> Optional[Any]:
+    return next((i for i in itr if i is not None), None)
+
+
+###############################################################################
+gl_input_files = ["man/nm-settings-docs-dbus.xml"]
+
+xml_roots = [ElementTree.parse(f).getroot() for f in gl_input_files]
+assert all(root.tag == "nm-setting-docs" for root in xml_roots)
+settings_roots = [node_to_dict(root, "setting", "name") for root in xml_roots]
+
+root_node = ElementTree.Element("nm-setting-docs")
+print("")
+script = "This file was generated by tools/generate-settings-dataclasses.py"
+license_and_this_file_was_generated_by_script = f"""# {script},
+# if possible, please make changes by also updating the script.
+# SPDX-License-Identifier: LGPL-2.1-or-later
+"""
+i = open("sdbus_async/networkmanager/settings/__init__.py", mode="w")
+i.write(license_and_this_file_was_generated_by_script)
+classes = []
+for settingname in iter_keys_of_dicts(settings_roots, key_fcn_setting_name):
+    settings = [d.get(settingname) for d in settings_roots]
+    properties = [node_to_dict(s, "property", "name") for s in settings]
+    if properties == [OrderedDict()]:
+        continue
+    module = settingname.replace('-', '_')
+    for prefix in ["6", "802_11_", "802_1", "802_3_"]:
+        if module.startswith(prefix):
+            module = module.replace(prefix, "")
+            break
+    classname = module.replace("_", "").title() + "Settings"
+    i.write(f"from .{module} import {classname}\n")
+    classes.append(classname)
+    f = open(f"sdbus_async/networkmanager/settings/{module}.py", mode="w")
+    f.write(license_and_this_file_was_generated_by_script)
+    f.write("from dataclasses import dataclass, field\n")
+    f.write("from typing import List, Optional\n")
+    f.write("from .base import NetworkManagerSettingsMixin\n")
+    if settingname.startswith("ipv"):
+        f.write("from .datatypes import AddressData, RouteData\n")
+    f.write("\n\n")
+
+    setting_node = ElementTree.SubElement(root_node, "setting")
+    print(f"    {module}: Optional[{classname}] = field(")
+    print(f"        metadata={{'dbus_name': '{settingname}',")
+    print(f"                  'settings_class': {classname}}},")
+    print("        default=None,")
+    print("    )")
+    print("")
+    f.write("@dataclass\n")
+    f.write(f"class {classname}(NetworkManagerSettingsMixin):\n")
+    setting_node.set("name", settingname)
+    desc = node_get_attr(settings, "description")
+    f.write('    """' + desc + '"""\n\n')
+    # node_set_attr(setting_node, "alias", settings)
+    for property_name in iter_keys_of_dicts(properties):
+        properties_attrs = [p.get(property_name) for p in properties]
+        property_node = ElementTree.SubElement(setting_node, "property")
+        property_node.set("name", property_name)
+        t = node_get_attr(properties_attrs, "type")
+        attribute = property_name.replace('-', '_')
+        for builtin in ["id", "type"]:
+            if attribute == builtin:
+                attribute = f"{module}_{attribute}"
+
+        if not t:
+            t = "string"
+        if t.startswith("array of legacy"):
+            print("    # Deprecated - TODO: ignore")
+            continue
+        if t not in dbus_name_type_map:
+            print(f"    # {settingname}.{property_name} type [{t}] not found")
+            ty = t.replace(")", "")[-5:]
+            if ty in dbus_name_type_map:
+                t = ty
+        if t in ["{sv}'"]:
+            t = "{sv}"
+        if t in ["array of 'a{sv}'"]:
+            if f"{settingname}.{property_name}" == "wireguard.peers":
+                print("# Has special class in settings.py")
+            continue
+        dbustype = dbus_name_type_map[t]
+        if t == "array of vardict":
+            default = node_get_attr(properties_attrs, "default")
+            inner_cls = (
+                property_name.title().replace("-", "").replace("data", "Data")
+            )
+            f.write(f"    {attribute}: Optional[List[{inner_cls}]] = field(\n")
+            f.write(f"        metadata={{'dbus_name': '{property_name}',\n")
+            f.write(f"                  'dbus_type': '{dbustype}',\n")
+            f.write(f"                  'dbus_inner_class': {inner_cls}}},\n")
+            f.write(f"        default={str(default).title()},\n    )\n")
+        else:
+            attribute_type = dbus_type_name_map[dbustype]
+            f.write(f"    {attribute}: Optional[{attribute_type}] = field(\n")
+            meta = f"'dbus_name': '{property_name}', 'dbus_type':@'{dbustype}'"
+            line = "metadata={" + meta + "},"
+            wrapper = textwrap.TextWrapper(
+                width=80,
+                initial_indent="        ",
+                subsequent_indent="                  ",
+            )
+            word_list = wrapper.wrap(text=line)
+            for element in word_list:
+                f.write(element.replace(":@", ": ") + '\n')
+            default = node_get_attr(properties_attrs, "default")
+            if default in ["{}", "0", "-1"]:
+                default = "None"
+            f.write(f"        default={str(default).title()},\n    )\n")
+            generate_descriptions_for_attributes = False
+            if generate_descriptions_for_attributes:
+                desc = node_get_attr(properties_attrs, "description")
+                wrapper = textwrap.TextWrapper(
+                    width=74, initial_indent="    ", subsequent_indent="    "
+                )
+                word_list = wrapper.wrap(text=f'"""{desc}')
+                if len(word_list) == 1:
+                    print(word_list[0] + '"""')
+                else:
+                    for element in word_list:
+                        f.write(element)
+                    f.write('    """')
+                f.write("")
+            # node_set_attr(property_node, "alias", properties_attrs)
+i.write('__all__ = (')
+for dclass in classes:
+    i.write(f"'{dclass}', ")
+i.write(")\n")