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

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/templates/apps/client.lua.mako

@@ -104,26 +104,41 @@ ${default_intf.render(default_path, ClassName, rpc['intf_class'], rpc['interface
 
 % for rpc in root['interfaces']:
   % if 'paths' in rpc and not rpc['virtual']:
-function ${ClassName}:MutipleGet${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["paths"])})
+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)
-  return foreach_non_virtual_interface_objects(self:get_bus(), '${rpc['interface']}', cb, ${'true' if rpc['retry'] else 'false'}, ${render_utils.get_path_patterns(rpc["paths"])})
+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)
-    self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_properties_changed(self:get_bus(), ${render_utils.get_path_patterns(rpc["paths"])}, cb, '${rpc['interface']}'${render_utils.get_dep_properties(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)
-    self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_interfaces_added(self:get_bus(), ${render_utils.get_path_patterns(rpc["paths"])}, cb, '${rpc['interface']}')
+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)
-    self.signal_slots[#self.signal_slots + 1] = subscribe_signal.on_interfaces_removed(self:get_bus(), ${render_utils.get_path_patterns(rpc["paths"])}, cb, '${rpc['interface']}')
+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 %>

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

@@ -0,0 +1,62 @@
+${make_header('lua')}
+local class = require 'mc.class'
+local db_base = require 'database.db_base'
+local Col = require 'database.column'
+<%namespace name="imports" file="../../../templates/apps/utils/imports.mako"/>
+${imports.render(root)}
+<%
+ClassName = root['package'] + 'Database'
+%>
+
+% for msg in root['data']:
+  % if render_utils.table_name(msg):
+---@class ${msg['name']}Table: Table
+% for prop in msg['properties']:
+---@field ${prop['name']} FieldBase
+% endfor
+  % endif
+
+% endfor
+
+---@class ${ClassName}
+---@field db DataBase
+% for msg in root['data']:
+  % if render_utils.table_name(msg):
+---@field ${msg['name']} ${msg['name']}Table
+  % endif
+% endfor
+local ${ClassName} = class(db_base)
+
+function ${ClassName}:ctor()
+% for msg in root['data']:
+  % if render_utils.table_name(msg):
+  self.${msg['name']} = self.db:Table('${render_utils.table_name(msg)}', {
+    % for prop in msg['properties']:
+    ${prop['name']} = Col.${render_utils.column_type(prop)}:cid(${prop['id']})${render_utils.primary_key(prop)}${render_utils.persistence_key(prop)}${render_utils.unique(prop)}${render_utils.allow_null(prop)}${render_utils.max_len(prop)}${render_utils.default(msg['name'], prop)}${render_utils.critical(prop)},
+    % endfor
+    % if render_utils.all_persistence(msg) != 'nil':
+    }, "${render_utils.all_persistence(msg)}"):create_if_not_exist(self.datas and self.datas['${render_utils.table_name(msg)}'])
+    % else:
+    }):create_if_not_exist(self.datas and self.datas['${render_utils.table_name(msg)}'])
+    % endif
+      % if render_utils.table_max_rows(msg) and render_utils.get_lua_codegen_version() >= 11:
+    self.${msg['name']}.table_max_rows = ${msg['options']['table_max_rows']}
+      %endif
+  % endif
+% endfor
+
+  self.tables = self.db.tables
+end
+
+% for msg in root['data']:
+  % if render_utils.table_name(msg):
+    % if render_utils.table_max_rows(msg) and render_utils.get_lua_codegen_version() >= 11:
+  
+function ${ClassName}:Register${msg['name']}TableMaxRowsCallback(cb)
+  self.${msg['name']}.table_max_rows_cb = cb
+end
+    % endif
+  % endif
+% endfor
+
+return ${ClassName}.new

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

@@ -0,0 +1,184 @@
+${make_header('lua')}
+local class = require 'mc.class'
+local db_base = require 'database.db_base'
+local Col = require 'database.column'
+<%namespace name="imports" file="../../../templates/apps/utils/imports.mako"/>
+${imports.render(root)}
+<%
+has_poweroff, has_reset, has_temporary = render_utils.check_local_per_type(root)
+%>
+
+local db_selector = {}
+
+% if has_poweroff:
+  <% ClassName = root['package'] + 'DatabasePoweroff' %>
+  % for msg in root['data']:
+    % if render_utils.table_name(msg) and render_utils.check_local_per_poweroff(msg):
+---@class ${msg['name']}Table: Table
+  % for prop in msg['properties']:
+---@field ${prop['name']} FieldBase
+  % endfor
+    % endif
+
+  % endfor
+
+---@class ${ClassName}
+---@field db DataBase
+  % for msg in root['data']:
+    % if render_utils.table_name(msg) and render_utils.check_local_per_poweroff(msg):
+---@field ${msg['name']} ${msg['name']}Table
+    % endif
+  % endfor
+
+local ${ClassName} = class(db_base)
+
+function ${ClassName}:ctor()
+  % for msg in root['data']:
+    % if render_utils.table_name(msg) and render_utils.check_local_per_poweroff(msg):
+  self.${msg['name']} = self.db:Table('${render_utils.table_name(msg)}', {
+      % for prop in msg['properties']:
+    ${prop['name']} = Col.${render_utils.column_type(prop)}${render_utils.extend_field(prop)}:cid(${prop['id']})${render_utils.primary_key(prop)}${render_utils.unique(prop)}${render_utils.allow_null(prop)}${render_utils.max_len(prop)}${render_utils.default(msg['name'], prop)}${render_utils.deprecated(prop)},
+      % endfor
+    }):create_if_not_exist(self.datas and self.datas['${render_utils.table_name(msg)}'])
+      % if render_utils.table_max_rows(msg) and render_utils.get_lua_codegen_version() >= 11:
+    self.${msg['name']}.table_max_rows = ${msg['options']['table_max_rows']}
+      %endif
+    % endif
+  % endfor
+
+  self.tables = self.db.tables
+end
+
+% for msg in root['data']:
+  % if render_utils.table_name(msg) and render_utils.check_local_per_poweroff(msg):
+    % if render_utils.table_max_rows(msg) and render_utils.get_lua_codegen_version() >= 11:
+  
+function ${ClassName}:Register${msg['name']}TableMaxRowsCallback(cb)
+  self.${msg['name']}.table_max_rows_cb = cb
+end
+    % endif
+  % endif
+% endfor
+
+db_selector["poweroff"] = ${ClassName}.new
+% endif
+
+% if has_reset:
+  <% ClassName = root['package'] + 'DatabaseReset' %>
+  % for msg in root['data']:
+    % if render_utils.table_name(msg) and render_utils.check_local_per_reset(msg):
+---@class ${msg['name']}Table: Table
+  % for prop in msg['properties']:
+---@field ${prop['name']} FieldBase
+  % endfor
+    % endif
+
+  % endfor
+
+---@class ${ClassName}
+---@field db DataBase
+  % for msg in root['data']:
+    % if render_utils.table_name(msg) and render_utils.check_local_per_reset(msg):
+---@field ${msg['name']} ${msg['name']}Table
+    % endif
+  % endfor
+
+local ${ClassName} = class(db_base)
+
+function ${ClassName}:ctor()
+  % for msg in root['data']:
+    % if render_utils.table_name(msg) and render_utils.check_local_per_reset(msg):
+  self.${msg['name']} = self.db:Table('${render_utils.table_name(msg)}', {
+      % for prop in msg['properties']:
+    ${prop['name']} = Col.${render_utils.column_type(prop)}${render_utils.extend_field(prop)}:cid(${prop['id']})${render_utils.primary_key(prop)}${render_utils.unique(prop)}${render_utils.allow_null(prop)}${render_utils.max_len(prop)}${render_utils.default(msg['name'], prop)}${render_utils.deprecated(prop)},
+      % endfor
+    }):create_if_not_exist(self.datas and self.datas['${render_utils.table_name(msg)}'])
+      % if render_utils.table_max_rows(msg) and render_utils.get_lua_codegen_version() >= 11:
+    self.${msg['name']}.table_max_rows = ${msg['options']['table_max_rows']}
+      %endif
+    % endif
+  % endfor
+
+  self.tables = self.db.tables
+end
+
+% for msg in root['data']:
+  % if render_utils.table_name(msg) and render_utils.check_local_per_reset(msg):
+    % if render_utils.table_max_rows(msg) and render_utils.get_lua_codegen_version() >= 11:
+  
+function ${ClassName}:Register${msg['name']}TableMaxRowsCallback(cb)
+  self.${msg['name']}.table_max_rows_cb = cb
+end
+    % endif
+  % endif
+% endfor
+
+db_selector["reset"] = ${ClassName}.new
+% endif
+
+% if has_temporary:
+  <% ClassName = root['package'] + 'DatabaseTemporary' %>
+  % for msg in root['data']:
+    % if render_utils.table_name(msg) and render_utils.check_local_per_temporary(msg):
+---@class ${msg['name']}Table: Table
+  % for prop in msg['properties']:
+---@field ${prop['name']} FieldBase
+  % endfor
+    % endif
+
+  % endfor
+
+---@class ${ClassName}
+---@field db DataBase
+  % for msg in root['data']:
+    % if render_utils.table_name(msg) and render_utils.check_local_per_temporary(msg):
+---@field ${msg['name']} ${msg['name']}Table
+    % endif
+  % endfor
+
+local ${ClassName} = class(db_base)
+
+function ${ClassName}:ctor()
+  local db = Databases(path)
+  local obj = {db = db}
+
+  % for msg in root['data']:
+    % if render_utils.table_name(msg) and render_utils.check_local_per_temporary(msg):
+  self.${msg['name']} = self.db:Table('${render_utils.table_name(msg)}', {
+      % for prop in msg['properties']:
+    ${prop['name']} = Col.${render_utils.column_type(prop)}${render_utils.extend_field(prop)}:cid(${prop['id']})${render_utils.primary_key(prop)}${render_utils.unique(prop)}${render_utils.allow_null(prop)}${render_utils.max_len(prop)}${render_utils.default(msg['name'], prop)}${render_utils.deprecated(prop)},
+      % endfor
+    }):create_if_not_exist(self.datas and self.datas['${render_utils.table_name(msg)}'])
+      % if render_utils.table_max_rows(msg) and render_utils.get_lua_codegen_version() >= 11:
+    self.${msg['name']}.table_max_rows = ${msg['options']['table_max_rows']}
+      %endif
+    % endif
+  % endfor
+
+  self.tables = self.db.tables
+  return setmetatable(obj, ${ClassName})
+end
+
+% for msg in root['data']:
+  % if render_utils.table_name(msg) and render_utils.check_local_per_temporary(msg):
+    % if render_utils.table_max_rows(msg) and render_utils.get_lua_codegen_version() >= 11:
+  
+function ${ClassName}:Register${msg['name']}TableMaxRowsCallback(cb)
+  self.${msg['name']}.table_max_rows_cb = cb
+end
+    % endif
+  % endif
+% endfor
+
+db_selector["temporary"] = ${ClassName}.new
+% endif
+
+<% ClassName = root['package'] + 'Database' %>
+local ${ClassName} = {}
+${ClassName}.__index = ${ClassName}
+
+function ${ClassName}.new(path, datas, type)
+    return db_selector[type] and db_selector[type](path, datas) or nil
+end
+
+return ${ClassName}.new

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

@@ -0,0 +1,35 @@
+${make_header('lua')}
+<%
+messages = [msg for msg in root['data'] if msg['type'] != 'Enum']
+enums = [msg for msg in root['data'] if msg['type'] == 'Enum']
+%>
+local validate = require 'mc.validate'
+local utils = require 'mc.utils'
+% if len(enums) > 0:
+local create_enum_type = require 'mc.enum'
+% endif
+<%namespace name="message" file="../../../templates/apps/utils/message.mako"/>
+<%namespace name="imports" file="../../../templates/apps/utils/imports.mako"/>
+<%namespace name="enum" file="../../../templates/apps/utils/enum.mako"/>
+<%namespace name="mdb_intf" file= "utils/mdb_intf.lua.mako"/>
+${imports.render(root)}
+
+local ${root['package']} = {}
+
+% for msg in enums:
+${enum.render(msg, 'create_enum_type')}
+${root['package']}.${msg['name']} = E${msg['name']}
+
+% endfor
+
+% for msg in messages:
+${message.render(msg, root.get('intf', {}).get('name', ''))}
+
+${root['package']}.${msg['name']} = T${msg['name']}
+% endfor
+
+% if 'intf' in root:
+${root['package']}.interface = ${mdb_intf.render(root['intf'])}
+
+% endif
+return ${root['package']}

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

@@ -1,7 +1,7 @@
 ${make_header('lua')}
 <%namespace name="imports" file="../../../templates/apps/utils/imports.mako"/>
 <%namespace name="default_intf" file="../../../templates/apps/utils/default_intf.lua.mako"/>
-<%namespace name="mdb_obj" file= "../../../templates/apps/utils/mdb_obj.lua.mako"/>
+<%namespace name="mdb_obj" file= "utils/mdb_obj.lua.mako"/>
 <% has_signal = root['signals']%>
 <% has_mdb = any('path' in cls_data for cls, cls_data in root['class_require'].items())%>
 <% has_default = any((rpc['default'] != '' and not rpc['override']) for rpc in root['methods'])%>
@@ -10,7 +10,7 @@ ${make_header('lua')}
 % if root['has_ipmi_cmd']:
 local ipmi = require 'ipmi'
 % endif
-% if has_default or has_mdb:
+% if has_default:
 local mdb = require 'mc.mdb'
 % endif
 local class = require 'mc.class'
@@ -26,12 +26,10 @@ local object_manage = require 'mc.mdb.object_manage'
 local persist_client = require 'persistence.persist_client_lib'
 % endif
 
-% for intf, intf_data in root['intf_imports'].items():
-local ${intf}Types = require '${project_name}.json_types.${intf}'
-% endfor
+local class_data = {}
 
 % for cls, cls_data in root['class_require'].items():
-${mdb_obj.render(cls, cls_data['data'], root['class_require'])}
+    class_data.${cls} = {${mdb_obj.render(cls, cls_data['data'], root['class_require'])}}
 % endfor
 
 % if root['path_level'] == 2:
@@ -123,6 +121,7 @@ function ${ClassName}:ctor(${"" if root['path_level'] == 2 else "bus"})
   % if utils_py.has_db(root):
     self.db_types = ${utils_py.get_db_types(root)}
   % endif
+    self.class_data = class_data
     self.name = '${project_name}'
 end
 

bmcgo/codegen/lua/v1/templates/apps/utils/mdb_intf.lua.mako

@@ -0,0 +1,27 @@
+<%def name="render(intf)">
+{
+ '${intf['name']}', {
+  % if 'properties' in intf['data'] :
+    % for p,p_data in intf['data']['properties'].items():
+      ${p} = {'${render_utils.do_type_to_dbus_json(intf['data'], p_data)}', ${render_utils.options_json(p_data)}, ${render_utils.readonly_json(p_data)}, ${render_utils.default_json(p_data)}, false},
+    % endfor
+  % endif
+  }, {
+  % if 'methods' in intf['data'] :
+    % for method, method_data in intf['data']['methods'].items():
+% if version >= 16:
+      ${method} = {'a{ss}${render_utils.do_types_to_dbus_json(intf['data'], method_data, 'req')}', '${render_utils.do_types_to_dbus_json(intf['data'], method_data,'rsp')}', T${method}Req, T${method}Rsp${render_utils.get_method_description(intf['name'], method_data)}},
+% else:
+      ${method} = {'a{ss}${render_utils.do_types_to_dbus_json(intf['data'], method_data, 'req')}', '${render_utils.do_types_to_dbus_json(intf['data'], method_data,'rsp')}', T${method}Req, T${method}Rsp},
+%endif
+    % endfor
+  % endif
+  }, {
+  % if 'signals' in intf['data'] :
+    % for s,s_data in intf['data']['signals'].items():
+      ${s} = 'a{ss}${render_utils.do_types_to_dbus_json(intf['data'], intf['data']['signals'], s)}',
+    % endfor
+  % endif
+  }
+}
+</%def>

bmcgo/codegen/lua/v1/templates/apps/utils/mdb_obj.lua.mako

@@ -0,0 +1,14 @@
+
+
+<%def name="render(class_name, class_data, class_require)">
+  % if 'path' in class_data:
+    path = '${render_utils.get_path(class_name, class_require)}',
+    % if 'interfaces' in class_data:
+      interface_data = {
+        % for intf in class_data['interfaces']:
+          {name = '${intf}'},
+        % endfor
+      }
+    %endif
+  %endif
+</%def>

{openubmc_bingo-0.5.257.dist-info → openubmc_bingo-0.5.261.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openubmc-bingo
-Version: 0.5.257
+Version: 0.5.261
 Summary: Tools provided by openubmc
 Home-page: https://openubmc.cn
 Classifier: Programming Language :: Python :: 3