Renamed generator regex filter option to --settings-regex-filter

Author: igo95862

tools/generate-settings-dataclasses-jinja.py

@@ -273,27 +273,33 @@ def generate_introspection(root: Element) -> List[NmSettingsIntrospection]:
 
 def main(
         settings_xml_path: Path,
-        regex_filter: Optional[Pattern] = None,
+        settings_regex_filter: Optional[Pattern] = None,
 ) -> None:
     jinja_env = Environment(
         loader=FileSystemLoader(Path('./tools/jinja_templates/')),
     )
     settings_template = jinja_env.get_template('setting.py.jinja2')
 
     tree = parse(settings_xml_path)
-    introspection = generate_introspection(tree.getroot())
+    all_settings = generate_introspection(tree.getroot())
 
     settings_dir = Path('./sdbus_async/networkmanager/settings/')
-    for setting in introspection:
+    for setting in all_settings:
 
-        if regex_filter is not None:
-            if not regex_filter.match(setting.snake_name):
+        if settings_regex_filter is not None:
+            if not settings_regex_filter.match(setting.snake_name):
                 continue
 
         setting_py_file = settings_dir / (setting.snake_name + '.py')
         with open(setting_py_file, mode='w') as f:
             f.write(settings_template.render(setting=setting))
 
+    profile_template = jinja_env.get_template('profile.py.jinja2')
+    with open(settings_dir / 'profile.py', mode='w') as f:
+        f.write(profile_template.render(
+            all_settings=sorted(all_settings, key=lambda x: x.snake_name))
+        )
+
 
 if __name__ == '__main__':
     arg_parser = ArgumentParser()
@@ -303,7 +309,7 @@ def main(
         default=Path('./nm-settings-docs-dbus.xml'),
     )
     arg_parser.add_argument(
-        '--regex-filter',
+        '--settings-regex-filter',
         type=regex_compile,
     )
 

tools/jinja_templates/profile.py.jinja2

@@ -0,0 +1,152 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# This file was generated by tools/generate-settings-dataclasses-jinja.py,
+# if possible, please make changes by also updating the script.
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from typing import Any, Dict, Optional
+
+from .base import NetworkManagerSettingsMixin
+{% for setting in all_settings -%}
+from .{{ setting.snake_name }} import {{ setting.python_class_name }}
+{% endfor -%}
+from ..types import NetworkManagerConnectionProperties, SettingsDict
+
+
+@dataclass
+class ConnectionProfile:
+    """
+    Connection profiles
+    -------------------
+
+    NetworkManager is based on a concept of connection profiles, most often
+    referred to just as "connections". Connection profiles provide a network
+    configuration. When NetworkManager activates a connection profile on a
+    network device, the configuration will be applied and an active network
+    connection will be established. Users are free to create as many
+    connection profiles as they see fit. Thus they are flexible in having
+    various network configurations for different networking needs:
+    https://networkmanager.pages.freedesktop.org/NetworkManager/NetworkManager/nm-settings-dbus.html
+
+    Connection profiles are handled by NetworkManager via a settings service
+    and are exported on D-Bus (/org/freedesktop/NetworkManager/Settings/<num>)
+
+    Definition of a connection profile:
+    A specific, encapsulated, independent group of settings describing
+    all the configuration required to connect to a specific network.
+
+    It is referred to by a unique identifier called the UUID.
+    A connection profile is tied to a one specific device type,
+    but not necessarily a specific hardware device.
+
+    A connection profile is composed of one or more Settings objects.
+
+    Settings objects
+    ----------------
+
+    A group of related key/value pairs describing a specific piece
+    of a Connection (profile). Keys are also referred to as properties.
+    """
+    # The settings object "connection" is special: It must always be present
+    # because it contains the UUID and the connection type which are required:
+    connection: ConnectionSettings = field(
+        metadata={'dbus_name': 'connection',
+                  'settings_class': ConnectionSettings},
+    )
+    # The list of the remaining settings classes was generated by
+    # tools/generate-settings-dataclasses-jinja.py which generates the
+    # settings classes themselfes as well.
+    # If possible, please make changes by also updating the script.
+
+    # start of the generated list of settings classes
+{%- for setting in all_settings %}
+    {{ setting.snake_name }}: Optional[{{ setting.python_class_name }}] = field(
+        metadata={'dbus_name': '{{ setting.name }}',
+                  'settings_class': {{ setting.python_class_name }}},
+        default=None,
+    )
+{%- endfor %}
+    # end of the generated list of settings classes
+
+    def to_dbus(self) -> NetworkManagerConnectionProperties:
+        new_dict: NetworkManagerConnectionProperties = {}
+
+        for x in fields(self):
+            value = getattr(self, x.name)
+            if value is None:
+                continue
+
+            new_dict[x.metadata['dbus_name']] = value.to_dbus()
+
+        return new_dict
+
+    def to_settings_dict(self, defaults: bool = False) -> SettingsDict:
+        """Return a simple dictionary using the same key names like the dbus
+        dict from to_dbus(), but without the dbus signatures returned by it.
+
+        Contrary to dataclasses.asdict(), it provides the orignal dbus keys,
+        e.g. with numerical prefixes like "802-11-", dashes, and "id"/"type".
+
+        The key names provided are exactly as documented in these tables:
+        https://networkmanager.dev/docs/api/latest/nm-settings-dbus.html
+
+        param defaults: Whether properies with default values are returned.
+        """
+        new_dict = {}
+        for x in fields(self):
+            settings_class = getattr(self, x.name)
+            if settings_class:
+                settingsdomain_dict = settings_class.to_settings_dict(defaults)
+                if settingsdomain_dict != {}:
+                    new_dict[x.metadata['dbus_name']] = settingsdomain_dict
+        return new_dict
+
+    @property
+    def dbus_name_to_settings_class(self) -> Dict[str, str]:
+        return {f.metadata['dbus_name']: f.name
+                for f in fields(self)}
+
+    @classmethod
+    def from_dbus(cls, dbus_dict: NetworkManagerConnectionProperties
+                  ) -> ConnectionProfile:
+        for domain in ("ipv4", "ipv6"):
+            group = dbus_dict.get(domain, None)
+            if group:
+                for key in ("addresses", "routes"):
+                    group.pop(key, None)
+        try:
+            unvarianted_options: Dict[str, Any] = {
+                SETTING_DBUS_NAME_TO_NAME[k]: SETTING_TO_CLASS[k].from_dbus(v)
+                for k, v in dbus_dict.items()}
+        except KeyError as e:
+            print(dbus_dict)
+            raise e
+        return cls(**unvarianted_options)
+
+    @classmethod
+    def from_settings_dict(
+        cls, settings_dict: SettingsDict
+    ) -> ConnectionProfile:
+        """Return a ConnectionProfile created from a simple settings dict
+        A simple settings dict uses the same keys as from_dbus() and to_dbus()
+        but without the dbus variable signatures used by NetworkManader.py
+
+        This means a simple settings dict does not use the underscore in keys
+        like the attributes of this class have to use and use "id" and "type".
+        """
+        unvarianted_options: Dict[str, Any] = {
+            SETTING_DBUS_NAME_TO_NAME[k]: SETTING_TO_CLASS[k].from_dict(v)
+            for k, v in settings_dict.items()}
+        return cls(**unvarianted_options)
+
+
+SETTING_DBUS_NAME_TO_NAME: Dict[str, str] = {
+    f.metadata['dbus_name']: f.name
+    for f in fields(ConnectionProfile)
+}
+
+SETTING_TO_CLASS: Dict[str, NetworkManagerSettingsMixin] = {
+    f.metadata['dbus_name']: f.metadata['settings_class']
+    for f in fields(ConnectionProfile)
+}
+