openubmc-bingo 0.5.254__py3-none-any.whl → 0.5.261__py3-none-any.whl

bmcgo/codegen/lua/v1/script/render_utils/client_lua.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+# coding=utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+from utils import Utils
+from bmcgo.codegen.lua.script.dto.options import Options
+from bmcgo.codegen.lua.script.mdb_register import MdbRegister
+from bmcgo.codegen.lua.script.base import Base
+from bmcgo.codegen.lua.script.factory import Factory
+
+
+class ConsistencyClientLuaUtils(Base, Utils, MdbRegister):
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def message_type(t):
+        if t == ".google.protobuf.Empty":
+            return 'nil'
+        return t[1:] if t.startswith('.') else t
+
+    def sig(self, msg_type):
+        msg = Utils(self.data, self.options).make_get_message(msg_type)
+        return "".join(
+            [Utils(self.data, self.options).do_type_to_dbus(p['type'], p['repeated']) for p in msg.get('properties')])
+
+    def props(self, msg_type):
+        msg = Utils(self.data, self.options).make_get_message(msg_type)
+        return msg.get('properties')
+
+    def params(self, msg_type):
+        return ", ".join([p['name'] for p in self.props(msg_type)])
+
+    def cb_name(self, rpc):
+        return Utils(self.data, self.options).camel_to_snake('__On' + rpc['name'])
+
+    def rsp_message(self, rpc):
+        return self.message_type(rpc['rsp'])
+
+    def req_message(self, rpc):
+        return self.message_type(rpc['req'])
+
+    def make_path_with_params(self, path):
+        path = self.force_to_colon(path)
+        params = self.get_path_params(path)
+        if not params:
+            return f"'{path}'"
+        result = []
+        for name in params:
+            parts = path.partition(f':{name}')
+            result.append(f"'{parts[0]}'")
+            result.append(f"path_params['{name}']")
+            path = parts[2]
+        ret = ' .. '.join(result)
+        if path:
+            ret += f" .. '{path}'"
+        return ret
+
+    def get_path_arg(self, path, with_comma=True):
+        if not self.get_path_params(path):
+            return ""
+        if with_comma:
+            return ", path_params"
+        return "path_params"
+
+    def get_path_namespace_name(self, index):
+        return f"path_namespace{index + 1}"
+
+    def get_path_namespace_list(self, paths):
+        indexed_path_namespace = [
+            f"path_namespace{index + 1}"
+            for index, _ in enumerate(paths)
+        ]
+        return "{" + ", ".join(indexed_path_namespace) + "}"
+
+    def get_dep_properties(self, properties):
+        if properties == ["*"]:
+            return ""
+
+        return ', {"' + '", "'.join(properties) + '"}'
+
+    def get_path_namespace(self, path):
+        if not self.get_path_params(path):
+            return f"'{path}'"
+        path_with_params = self.make_path_with_params(path)
+        if Utils.get_lua_codegen_version() >= 17:
+            return f"path_params and ({path_with_params}) or '{path}'"
+        prefix = path_with_params.split("/' ..")[0]
+        return f"path_params and ({path_with_params}) or {prefix}'"
+
+    def get_path_patterns(self, paths):
+        return MdbRegister.convert_to_lua(self, paths)
+
+    def get_object_path(self, path):
+        if not self.get_path_params(path):
+            return f"'{path}'"
+        path_with_params = self.make_path_with_params(path)
+        return f"path_params and ({path_with_params}) or '{path}'"
+
+Factory().register("v1/templates/apps/client.lua.mako", ConsistencyClientLuaUtils)

bmcgo/codegen/lua/v1/script/render_utils/db_lua.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+# coding=utf-8
+# Copyright (c) 2024 Huawei Technologies Co., Ltd.
+# openUBMC is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#         http://license.coscl.org.cn/MulanPSL2
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+
+import json
+from utils import Utils
+from bmcgo.codegen.lua.script.dto.options import Options
+from bmcgo.codegen.lua.script.base import Base
+from bmcgo.codegen.lua.script.factory import Factory
+
+
+class ConsistencyDbLuaUtils(Base, Utils):
+    TYPE_TO_DB_MAP = {
+        "int8": 'IntegerField',
+        'uint8': 'IntegerField',
+        'int16': 'IntegerField',
+        'uint16': 'IntegerField',
+        'int32': 'IntegerField',
+        'uint32': 'IntegerField',
+        'int64': 'IntegerField',
+        'uint64': 'IntegerField',
+        'double': 'RealField',
+        'float': 'RealField',
+        'bytes': 'BolbField',
+        'string': 'TextField',
+        'bool': 'BooleandField',
+    }
+
+    per_type_map = {
+        'PoweroffPer': 'protect_power_off',
+        'ResetPer': 'protect_reset',
+        'PermanentPer': 'protect_permanent',
+        'TemporaryPer': 'protect_temporary',
+        'PoweroffPerRetain': 'protect_power_off_retain',
+        'ResetPerRetain': 'protect_reset_retain',
+        'TemporaryPerRetain': 'protect_temporary_retain'
+    }
+
+    def __init__(self, data: dict, options: Options):
+        super().__init__(data, options=options)
+
+    @staticmethod
+    def table_name(msg):
+        if msg['type'] != 'Message' or not msg['options'] or not msg['options']['table_name']:
+            return False
+
+        return msg['options']['table_name']
+
+    @staticmethod
+    def table_max_rows(msg):
+        return msg.get('type') == 'Message' and msg.get('options', {}).get('table_max_rows', False)
+
+    @staticmethod
+    def all_persistence(msg):
+        if msg['type'] != 'Message' or not msg['options']:
+            return 'nil'
+
+        if 'persistence' in msg['options']:
+            return msg['options']['persistence']
+
+        if 'table_type' in msg['options']:
+            if msg['options']['table_type'] in ConsistencyDbLuaUtils.per_type_map:
+                return ConsistencyDbLuaUtils.per_type_map[msg['options']['table_type']]
+        return 'nil'
+
+    @staticmethod
+    def check_local_per_type(root):
+        per_map = {
+            "PoweroffPer": False,
+            "ResetPer": False,
+            "TemporaryPer": False
+        }
+        for msg in root["data"]:
+            table_type = msg["options"].get("table_type", "PoweroffPer")
+            if table_type not in per_map:
+                continue
+            per_map[table_type] = True
+        return per_map.values()
+
+    @staticmethod
+    def check_local_per_poweroff(msg):
+        if "options" not in msg or "table_type" not in msg["options"]:
+            return True
+        return "options" in msg and "table_type" in msg["options"] and msg["options"]["table_type"] == "PoweroffPer"
+
+    @staticmethod
+    def check_local_per_reset(msg):
+        return "options" in msg and "table_type" in msg["options"] and msg["options"]["table_type"] == "ResetPer"
+
+    @staticmethod
+    def check_local_per_temporary(msg):
+        return "options" in msg and "table_type" in msg["options"] and msg["options"]["table_type"] == "TemporaryPer"
+
+    @staticmethod
+    def column_max_len(prop):
+        if prop['repeated']:
+            return 0
+        type_name = prop['type']
+        if type_name == "int8" or type_name == 'uint8':
+            return 8
+        if type_name == "int16" or type_name == 'uint16':
+            return 16
+        if type_name == "int32" or type_name == 'uint32':
+            return 32
+        if type_name == "int64" or type_name == 'uint64':
+            return 64
+        if 'max_len' in prop['options']:
+            return prop['options']['max_len']
+        return 0
+
+    @staticmethod
+    def unique(prop):
+        if 'unique' not in prop['options']:
+            return ''
+        return f':unique()'
+
+    @staticmethod
+    def primary_key(prop):
+        if 'primary_key' not in prop['options']:
+            return ''
+        return f':primary_key()'
+
+    @staticmethod
+    def persistence_key(prop):
+        if 'persistence_ex' in prop['options']:
+            val = prop['options']['persistence_ex']
+            return f':persistence_key("{val}")'
+
+        if 'usage' not in prop['options']:
+            return ''
+        val = ''
+        for use_type in prop['options']['usage']:
+            if use_type in ConsistencyDbLuaUtils.per_type_map:
+                val = ConsistencyDbLuaUtils.per_type_map[use_type]
+                break
+        if val == '':
+            return ''
+
+        return f':persistence_key("{val}")'
+
+    @staticmethod
+    def allow_null(prop):
+        if prop['options'].get('allow_null', False):
+            return ':null()'
+        return ''
+
+    @staticmethod
+    def extend_field(prop):
+        if prop['options'].get('extend_field', False):
+            return ':extend_field()'
+        return ''
+
+    @staticmethod
+    def deprecated(prop):
+        if prop['options'].get('deprecated', False):
+            return ':deprecated()'
+        return ''
+
+    @staticmethod
+    def critical(prop):
+        if prop['options'].get('critical', False):
+            return ':critical()'
+        return ''
+
+    def column_type(self, prop):
+        type_name = prop['type']
+        if type_name in self.TYPE_TO_DB_MAP:
+            if prop['repeated']:
+                return "JsonField()"
+            else:
+                return self.TYPE_TO_DB_MAP[type_name] + "()"
+        types = Utils(self.data, self.options).load_types(type_name)
+        if types and ('type' in types) and types['type'] == 'Enum':
+            return f'EnumField({types["package"]}.{types["name"]})'
+        return "JsonField()"
+
+    def max_len(self, prop):
+        num = self.column_max_len(prop)
+        if num == 0:
+            return ''
+        return f':max_length({num})'
+
+    def default(self, class_name, prop):
+        if 'default' not in prop['options']:
+            return ''
+        return f':default({self._convert_default_value(class_name, prop)})'
+
+    def _convert_default_value(self, class_name, prop):
+        d_val = prop['options']['default']
+        type_name = prop['type']
+        types = Utils(self.data, self.options).load_types(type_name)
+        if types and ('type' in types) and types['type'] == 'Enum':
+            if isinstance(d_val, list):
+                result = "{"
+                for val in d_val:
+                    enum_type = Utils(self.data, self.options).enum_value_name(types["name"], val)
+                    result += f'{types["package"]}.{types["name"]}.{enum_type},'
+                return result + "}"
+            value_name = Utils(self.data, self.options).enum_value_name(types["name"], d_val)
+            return f'{types["package"]}.{types["name"]}.{value_name}'
+        if Utils.get_lua_codegen_version() >= 10:
+            if prop.get('repeated') and not isinstance(d_val, list):
+                raise RuntimeError(f"model.json中类{class_name}的属性{prop['name']}默认值{d_val}类型与属性类型不一致")
+            if isinstance(d_val, list) or isinstance(d_val, dict):
+                json_str = json.dumps(d_val).replace("'", "''")
+                return f"[['{json_str}']]"
+        if type_name == "string" or type_name == 'bytes':
+            return f'"\'{d_val}\'"'
+        if type_name == "bool":
+            return str(bool(d_val)).lower()
+        return d_val
+
+
+Factory().register("v1/templates/apps/db.lua.mako", ConsistencyDbLuaUtils)
+Factory().register("v1/templates/apps/local_db.lua.mako", ConsistencyDbLuaUtils)

bmcgo/codegen/lua/v1/script/render_utils/model_lua.py

@@ -22,6 +22,10 @@ BASE_TYPE = "baseType"
 ITEMS = "items"
 NON_CONVERT_ITEMS = ["validator", "req_type", "rsp_type", "feature", "default_value", "read", "write"]
 FILTERED_ITEMS = ["description", "$ref", "default", "items", "req", "rsp", "featureTag", "privilege"]
+PERSIST_TYPES = {
+    "PermanentPer", "PoweroffPer", "ResetPer", "TemporaryPer", "PoweroffPerRetain",
+    "ResetPerRetain", "TemporaryPerRetain", "Memory"
+}
 OBJECT_PROPERTIES_INTERFACE = "bmc.kepler.Object.Properties"
 
 
@@ -67,6 +71,10 @@ class ConsistencyModelLuaUtils(Base, Utils):
     def combine_privileges(privileges):
         prefix = "privilege."
         return prefix + (" | " + prefix).join(sorted(privileges))
+    
+    @staticmethod
+    def prop_contains_persist_type(prop_config: dict):
+        return bool(set(prop_config.get("usage", [])) & PERSIST_TYPES)
 
     def class_has_block_io(self, msg):
         if self.has_path(msg):
@@ -175,6 +183,27 @@ class ConsistencyModelLuaUtils(Base, Utils):
             return msg['path']
         return msg['path'].replace(':parent/', self.get_path(root, root[msg['parent']]) + ':parent/')
 
+    def is_enable_orm(self, msg):
+        if "tableName" not in msg:
+            return False
+
+        if "tableLocation" in msg and msg["tableLocation"] == "Local":
+            return False
+
+        if "tableType" in msg:
+            return True
+
+        for _, prop_config in msg.get('properties', {}).items():
+            if self.prop_contains_persist_type(prop_config):
+                return True
+
+        for intf_data in msg.get('interfaces', {}).values():
+            for _, prop_config in intf_data.get('properties', {}).items():
+                if self.prop_contains_persist_type(prop_config):
+                    return True
+
+        return False
+
     def convert_dynamic_params(self, msg):
         match_obj = re.search("\$\{(.+?)\}", msg)
         if match_obj is None:

bmcgo/codegen/lua/v1/templates/apps/client.lua.mako

@@ -0,0 +1,244 @@
+## 生成所有rpc接口
+<%def name="get_obj(rpc)">
+% if rpc['path'] != '*': ## 非虚方法和收集类方法，直接远程调用
+  % if 'paths' in rpc and not rpc['virtual']:
+    %if not rpc['retry']:
+    mdb.get_object(self:get_bus(), ${render_utils.make_path_with_params(rpc['full_path'])}, '${rpc['interface']}')
+    %else:
+    mdb.try_get_object(self:get_bus(), ${render_utils.get_object_path(rpc['full_path'])}, '${rpc['interface']}')
+    %endif
+  % else:
+    self:Get${rpc['class']}${rpc['intf_class']}Object(${render_utils.get_path_arg(rpc["full_path"], False)})
+  % endif
+% elif not rpc['virtual']:
+    mdb.get_object(self:get_bus(), ${render_utils.make_path_with_params(rpc['full_path'])}, "${rpc['interface']}")
+% else :
+    self:Get${rpc['intf_class']}Object()
+% endif
+</%def>
+${make_header('lua')}
+<% has_signal = root['signals']%>
+<% has_interface = root['interfaces']%>
+<% has_definite_path = any((rpc['path'] != '*') for rpc in root['interfaces'])%>
+<% has_virtual = any((rpc['path'] == '*' and rpc['virtual']) for rpc in root['interfaces'])%>
+<% has_implement = any((rpc['implement'] != '') for rpc in root['interfaces'])%>
+<% has_non_virtual = any(((rpc['path'] == '*' or ((render_utils.get_path_params(rpc["full_path"]) or 'paths' in rpc))) and not rpc['virtual'] and rpc['implement'] == '') for rpc in root['interfaces'])%>
+% if has_definite_path or has_implement:
+local mdb = require 'mc.mdb'
+% endif
+local class = require 'mc.class'
+local app_base = require 'mc.client_app_base'
+% if has_signal or has_non_virtual:
+local mdb_service = require 'mc.mdb.mdb_service'
+% endif
+% if has_interface:
+local subscribe_signal = require 'mc.mdb.subscribe_signal'
+% endif
+% if has_signal:
+local org_freedesktop_dbus = require 'sd_bus.org_freedesktop_dbus'
+% endif
+
+% if has_signal:
+local match_rule = org_freedesktop_dbus.MatchRule
+% endif
+% if has_virtual:
+local get_virtual_interface_object = mdb_service.get_virtual_interface_object
+% endif
+% if has_non_virtual:
+local get_non_virtual_interface_objects = mdb_service.get_non_virtual_interface_objects
+local foreach_non_virtual_interface_objects = mdb_service.foreach_non_virtual_interface_objects
+% endif
+
+## 生成对接口的依赖
+% for intf, intf_data in root['intf_imports'].items():
+  % if intf_data['interface'].startswith('bmc.dev.'):
+local ${intf} = require '${project_name}.device_types.${intf}'
+  %else:
+local ${intf} = require '${project_name}.json_types.${intf}'
+  % endif
+% endfor
+
+<%namespace name="default_intf" file="../../../templates/apps/utils/default_intf.lua.mako"/>
+<%namespace name="imports" file="../../../templates/apps/utils/imports.mako"/>
+${imports.render(root)}
+
+<%
+ClassName = root['package'] + '_client'
+%>
+---@class ${ClassName}: BasicClient
+local ${ClassName} = class(app_base.Client)
+
+% if has_implement:
+${default_intf.add_subs(ClassName)}
+% endif
+## 收集复写类方法订阅接口
+% for rpc in root['interfaces']:
+  % if rpc['path'] == '*' and rpc['virtual']:
+
+function ${ClassName}:Get${rpc['intf_class']}Object()
+  return get_virtual_interface_object(self:get_bus(), '${rpc['interface']}')
+end
+  % endif
+%endfor
+## 生成收集类client订阅接口
+% for rpc in root['interfaces']:
+  %if rpc['path'] == '*' and not rpc['virtual'] and rpc['implement'] == '':
+
+function ${ClassName}:Get${rpc['intf_class']}Objects()
+  return get_non_virtual_interface_objects(self:get_bus(), '${rpc['interface']}', ${'true' if rpc['retry'] else 'false'})
+end
+
+function ${ClassName}:Foreach${rpc['intf_class']}Objects(cb)
+  return foreach_non_virtual_interface_objects(self:get_bus(), '${rpc['interface']}', cb, ${'true' if rpc['retry'] else 'false'})
+end
+  % endif
+%endfor
+
+## 生成默认对象的订阅和访问接口
+% for rpc in root['interfaces']:
+  %if rpc['implement'] != '' :
+    <% default_path = ClassName +'.'+ rpc['intf_class'] +"_default" %>
+${default_intf.render(default_path, ClassName, rpc['intf_class'], rpc['interface'])}
+  % endif
+%endfor
+
+% for rpc in root['interfaces']:
+  % if 'paths' in rpc and not rpc['virtual']:
+function ${ClassName}:MutipleGet${rpc['intf_class']}Objects(${render_utils.get_path_arg(rpc["paths"], False)})
+  % for path in rpc["paths"]:
+    local ${render_utils.get_path_namespace_name(loop.index)} = ${render_utils.get_path_namespace(path)}
+  %endfor
+  return get_non_virtual_interface_objects(self:get_bus(), '${rpc['interface']}', ${'true' if rpc['retry'] else 'false'}, ${render_utils.get_path_namespace_list(rpc["paths"])})
+end
+
+function ${ClassName}:MutipleForeach${rpc['intf_class']}Objects(cb${render_utils.get_path_arg(rpc["paths"])})
+  % for path in rpc["paths"]:
+    local ${render_utils.get_path_namespace_name(loop.index)} = ${render_utils.get_path_namespace(path)}
+  %endfor
+  return foreach_non_virtual_interface_objects(self:get_bus(), '${rpc['interface']}', cb, ${'true' if rpc['retry'] else 'false'}, ${render_utils.get_path_namespace_list(rpc["paths"])})
+end
+
+% if rpc['dep_properties']:
+function ${ClassName}:MutipleOn${rpc['intf_class']}PropertiesChanged(cb${render_utils.get_path_arg(rpc["paths"])})
+  % for path in rpc["paths"]:
+    local ${render_utils.get_path_namespace_name(loop.index)} = ${render_utils.get_path_namespace(path)}
+  %endfor
+  self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_properties_changed(self:get_bus(), ${render_utils.get_path_namespace_list(rpc["paths"])}, cb, '${rpc['interface']}'${render_utils.get_dep_properties(rpc["dep_properties"])})
+end
+%endif
+
+function ${ClassName}:MutipleOn${rpc['intf_class']}InterfacesAdded(cb${render_utils.get_path_arg(rpc["paths"])})
+  % for path in rpc["paths"]:
+    local ${render_utils.get_path_namespace_name(loop.index)} = ${render_utils.get_path_namespace(path)}
+  %endfor
+  self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_interfaces_added(self:get_bus(), ${render_utils.get_path_namespace_list(rpc["paths"])}, cb, '${rpc['interface']}')
+end
+
+function ${ClassName}:MutipleOn${rpc['intf_class']}InterfacesRemoved(cb${render_utils.get_path_arg(rpc["paths"])})
+  % for path in rpc["paths"]:
+    local ${render_utils.get_path_namespace_name(loop.index)} = ${render_utils.get_path_namespace(path)}
+  %endfor
+  self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_interfaces_removed(self:get_bus(), ${render_utils.get_path_namespace_list(rpc["paths"])}, cb, '${rpc['interface']}')
+end
+
+    <% continue %>
+  % endif
+  % if rpc['path'] != '*':
+function ${ClassName}:Get${rpc['name']}Object(${render_utils.get_path_arg(rpc["full_path"], False)})
+    %if not rpc['retry']:
+return mdb.get_object(self:get_bus(), ${render_utils.make_path_with_params(rpc['full_path'])}, '${rpc['interface']}')
+    %else:
+return mdb.try_get_object(self:get_bus(), ${render_utils.get_object_path(rpc['full_path'])}, '${rpc['interface']}')
+    %endif
+end
+
+  % if render_utils.get_path_params(rpc["full_path"]):
+function ${ClassName}:Get${rpc['intf_class']}Objects()
+  return get_non_virtual_interface_objects(self:get_bus(), '${rpc['interface']}', ${'true' if rpc['retry'] else 'false'}, ${render_utils.get_path_patterns([rpc["full_path"]])})
+end
+
+function ${ClassName}:Foreach${rpc['intf_class']}Objects(cb)
+  return foreach_non_virtual_interface_objects(self:get_bus(), '${rpc['interface']}', cb, ${'true' if rpc['retry'] else 'false'}, ${render_utils.get_path_patterns([rpc["full_path"]])})
+end
+  %endif
+
+% if rpc['dep_properties']:
+function ${ClassName}:On${rpc['intf_class']}PropertiesChanged(cb${render_utils.get_path_arg(rpc["full_path"])})
+    local path_namespace = ${render_utils.get_path_namespace(rpc['full_path'])}
+    self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_properties_changed(self:get_bus(), path_namespace, cb, '${rpc['interface']}'${render_utils.get_dep_properties(rpc["dep_properties"])})
+end
+%endif
+
+function ${ClassName}:On${rpc['intf_class']}InterfacesAdded(cb${render_utils.get_path_arg(rpc["full_path"])})
+    local path_namespace = ${render_utils.get_path_namespace(rpc['full_path'])}
+    self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_interfaces_added(self:get_bus(), path_namespace, cb, '${rpc['interface']}')
+end
+
+function ${ClassName}:On${rpc['intf_class']}InterfacesRemoved(cb${render_utils.get_path_arg(rpc["full_path"])})
+    local path_namespace = ${render_utils.get_path_namespace(rpc['full_path'])}
+    self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_interfaces_removed(self:get_bus(), path_namespace, cb, '${rpc['interface']}')
+end
+
+  % else :
+% if rpc['dep_properties']:
+function ${ClassName}:On${rpc['intf_class']}PropertiesChanged(cb)
+    self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_properties_changed(self:get_bus(), '/bmc', cb, '${rpc['interface']}'${render_utils.get_dep_properties(rpc["dep_properties"])})
+end
+%endif
+
+function ${ClassName}:On${rpc['intf_class']}InterfacesAdded(cb)
+    self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_interfaces_added(self:get_bus(), '/bmc', cb, '${rpc['interface']}')
+end
+
+function ${ClassName}:On${rpc['intf_class']}InterfacesRemoved(cb)
+    self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_interfaces_removed(self:get_bus(), '/bmc', cb, '${rpc['interface']}')
+end
+
+  % endif
+%endfor
+% for rpc in root['methods']:
+  %if rpc['path'] == '*'  and not rpc['virtual']:
+    <% continue %>
+  % endif
+  % for p in render_utils.props(rpc['req']): ## 生成参数注释
+---@param ${p['name']} ${utils_py.do_type_to_lua(p['type'], p['repeated'])}
+  % endfor
+  % if render_utils.rsp_message(rpc) != 'nil': ## 生成返回值注释
+---@return ${render_utils.rsp_message(rpc)}
+  % endif
+  % if len(render_utils.params(rpc['req'])) == 0: ## 区分参数个数生成参数, 没有参数的b
+function ${ClassName}:${rpc['name']}(ctx${render_utils.get_path_arg(rpc["full_path"])})
+  local obj = ${get_obj(rpc)}
+  return ${render_utils.rsp_message(rpc)}.new(obj:${rpc['func_name']}(ctx))
+end
+
+function ${ClassName}:P${rpc['name']}(ctx${render_utils.get_path_arg(rpc["full_path"])})
+  return pcall(self.${rpc['name']}, self, ctx${render_utils.get_path_arg(rpc["full_path"])})
+end
+
+  % else:  ## 有参数的
+function ${ClassName}:${rpc['name']}(ctx${render_utils.get_path_arg(rpc["full_path"])}, ${render_utils.params(rpc['req'])})
+  local req = ${render_utils.req_message(rpc)}.new(${render_utils.params(rpc['req'])}):validate()
+  local obj = ${get_obj(rpc)}return ${render_utils.rsp_message(rpc)}.new(obj:${rpc['func_name']}(ctx, req:unpack(true)))
+end
+
+function ${ClassName}:P${rpc['name']}(ctx${render_utils.get_path_arg(rpc["full_path"])}, ${render_utils.params(rpc['req'])})
+  return pcall(self.${rpc['name']}, self, ctx${render_utils.get_path_arg(rpc["full_path"])}, ${render_utils.params(rpc['req'])})
+end
+
+  % endif
+% endfor
+## 生成信号订阅接口
+% for signal in root['signals']:
+function ${ClassName}:Subscribe${signal['name']}(cb)
+  local sig = match_rule.signal('${signal['signal_name']}', '${signal['interface']}')${'' if signal['path'] == '*' else (':with_path("' +signal['path']+'")')}
+  self.signal_slots[#self.signal_slots+1] = subscribe_signal.subscribe(self:get_bus(), sig, cb)
+end
+
+% endfor
+function ${ClassName}:ctor()
+  self.signal_slots = {}
+end
+
+---@type ${ClassName}
+return ${ClassName}.new('${root['package']}')