lbkit 0.5.18__tar.gz → 0.5.20__tar.gz

{lbkit-0.5.18/lbkit.egg-info → lbkit-0.5.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.18
+Version: 0.5.20
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com

lbkit-0.5.20/lbkit/__init__.py

@@ -0,0 +1,2 @@
+
+__version__ = '0.5.20'

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit/cli.py

@@ -232,6 +232,9 @@ class Command(object):
             ret_code = -1
             msg = str(exc)
             log.error(misc.Color.RED + msg + misc.Color.RESET_ALL)
+        except errors.TestException:
+            log.error(exc)
+            ret_code = -1
 
         return ret_code
 

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit/codegen/idf_interface.py

@@ -8,6 +8,7 @@ from lbkit.codegen.renderer import Renderer
 from lbkit.codegen.ctype_defination import CTYPE_OBJS, RefObjArrayValidator, RefObjValidator
 from lbkit.misc import load_yml_with_json_schema_validate
 from lbkit.errors import OdfValidateException
+from lbkit.helper import SigInvalidException, validate_glib_signature
 
 log = Logger("gen_interface")
 
@@ -133,6 +134,7 @@ class IdfCtypeRender():
     ctype: str = None
     name: str = ""
     idf_data = None
+    default = None
     flags: list[str] = []
 
     def __init__(self):
@@ -186,20 +188,27 @@ class IdfCtypeRender():
         log.debug(f"Get odf schema info, name: {self.name}, ctype: {self.ctype}")
         if "variant" == self.ctype:
             return None
+        validator_cfg = self.validator_cfg
         match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
         if match:
             if "refobj" in self.flags:
                 valiator = RefObjArrayValidator()
                 return valiator.odf_schema(allow_ref)
-            ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref)
+            ctype_obj = copy.deepcopy(CTYPE_OBJS.get(self.ctype))
+            validator = ctype_obj.validator
+            if validator_cfg:
+                validator.set_validator(validator_cfg, self.name)
+            return validator.odf_schema(allow_ref)
         match = re.match(f"^({CTYPE_BASE_REG})$", self.ctype)
         if match:
             if "refobj" in self.flags:
                 valiator = RefObjValidator()
                 return valiator.odf_schema(allow_ref)
             ctype_obj = CTYPE_OBJS.get(self.ctype)
-            return ctype_obj.validator.odf_schema(allow_ref)
+            validator = ctype_obj.validator
+            if validator_cfg:
+                validator.set_validator(validator_cfg, self.name)
+            return validator.odf_schema(allow_ref)
         # 非基础类型
         is_array = False
         ctype = self.ctype
@@ -519,13 +528,11 @@ class IdfCtypeRender():
             value = self.idf_data.get("pattern")
             if value:
                 cfg["pattern"] = value
-        elif (self.ctype == "byte" or self.ctype == "array[byte]" or
-            self.ctype == "int16" or self.ctype == "array[int16]" or
-            self.ctype == "uint16" or self.ctype == "array[uint16]" or
-            self.ctype == "int32" or self.ctype == "array[int32]" or
-            self.ctype == "uint32" or self.ctype == "array[uint32]" or
-            self.ctype == "int64" or self.ctype == "array[int64]" or
-            self.ctype == "uint64" or self.ctype == "array[uint64]"):
+        elif self.ctype in ["byte", "array[byte]", "int16", "array[int16]",
+                            "uint16", "array[uint16]", "int32", "array[int32]",
+                            "uint32", "array[uint32]","int64", "array[int64]",
+                            "uint64", "array[uint64]", "size", "array[size]",
+                            "ssize", "array[ssize]"]:
             value = self.idf_data.get("max")
             if value:
                 cfg["max"] = value
@@ -596,6 +603,128 @@ class IdfProperty(IdfCtypeRender):
         else:
             self.desc_flags = " | ".join(c_flags)
 
+        self._load_default()
+
+    def _load_default(self):
+        # 只有基础类型有default值
+        match = re.match(f"^array\[({CTYPE_BASE_REG})\]$", self.ctype)
+        if not match:
+            match = re.match(f"^({CTYPE_BASE_REG})$", self.ctype)
+        if not match:
+            return
+        self.default = self.idf_data.get("default")
+        if self.default is None:
+            return
+
+        if self.ctype in ["boolean", "array[boolean]"]:
+            return
+        pattern = self.idf_data.get("pattern")
+        if self.ctype == "string":
+            if pattern:
+                match = re.match(pattern, self.default)
+                if not match:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            return
+        if self.ctype == "array[string]":
+            if pattern:
+                for val in self.default:
+                    match = re.match(pattern, val)
+                    if not match:
+                        raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {val}")
+            return
+        if self.ctype == "object_path":
+            if pattern:
+                match = re.match(pattern, self.default)
+                if not match:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            match = re.match(f"^(/[A-Z0-9a-z_]+)+$", self.default)
+            if not match:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"^(/[A-Z0-9a-z_]+)+$\", get default: {self.default}")
+            return
+        if self.ctype == "array[object_path]":
+            for val in self.default:
+                if pattern:
+                    match = re.match(pattern, val)
+                    if not match:
+                        raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {val}")
+                match = re.match(f"^(/[A-Z0-9a-z_]+)+$", val)
+                if not match:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"^(/[A-Z0-9a-z_]+)+$\", get default: {val}")
+            return
+
+        if self.ctype == "signature":
+            try:
+                validate_glib_signature(self.default)
+                if pattern:
+                    match = re.match(pattern, self.default)
+                    if not match:
+                        raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            except SigInvalidException:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}")
+            return
+        if self.ctype == "array[oobject_path]":
+            try:
+                for val in self.default:
+                    validate_glib_signature(val)
+                    if pattern:
+                        match = re.match(pattern, self.default)
+                        if not match:
+                            raise OdfValidateException(f"Fail to validation default value of property {self.name} with pattern \"{pattern}\", get default: {self.default}")
+            except SigInvalidException:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}")
+            return
+
+        cfg = self.validator_cfg
+        if self.ctype in ["byte", "int16", "uint16", "int32", "uint32", "size", "ssize",
+                          "int64", "uint64"]:
+            mmax = cfg.get("max")
+            if mmax is not None and mmax < self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, max: {mmax}")
+            mmin = cfg.get("min")
+            if mmin is not None and mmin > self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, min: {mmin}")
+            return
+        if self.ctype in ["array[byte]", "array[int16]", "array[uint16]", "array[int32]", "array[uint32]", "array[size]",
+                          "array[ssize]", "array[int64]", "array[uint64]"]:
+            for val in self.default:
+                mmax = cfg.get("max")
+                if mmax is not None and mmax < val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, max: {mmax}")
+                mmin = cfg.get("min")
+                if mmin is not None and mmin > val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, min: {mmin}")
+            return
+
+        if self.ctype == "double":
+            emax = cfg.get("exclusive_max")
+            mmax = cfg.get("max")
+            if emax is not None and emax <= self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, eclusive_max: {emax}")
+            if mmax is not None and mmax < self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, max: {mmax}")
+            emin = cfg.get("exclusive_min")
+            mmin = cfg.get("min")
+            if emin is not None and emin >= self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, exclusive_min: {emin}")
+            if mmin is not None and mmin > self.default:
+                raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {self.default}, min: {emin}")
+            return
+        if self.ctype == "array[double]":
+            for val in self.default:
+                emax = cfg.get("exclusive_max")
+                mmax = cfg.get("max")
+                if emax is not None and emax <= val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, eclusive_max: {emax}")
+                if mmax is not None and mmax < val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, max: {mmax}")
+                emin = cfg.get("exclusive_min")
+                mmin = cfg.get("min")
+                if emin is not None and emin >= val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, exclusive_min: {emin}")
+                if mmin is not None and mmin > val:
+                    raise OdfValidateException(f"Fail to validation default value of property {self.name}, get default: {val}, min: {emin}")
+            return
+        raise OdfValidateException(f"Only basic type(byaqiuxtdsog) support default value, Property {self.name} type is {self.ctype}")
 
     @property
     def signature(self):
@@ -819,8 +948,8 @@ class IdfDictionary():
 
 class IdfInterface(IdfInterfaceBase):
     def __init__(self, lookup, idf_file):
-        if not idf_file.endswith(".yaml"):
-            raise IDFException(f"IDF file {idf_file} not endswith .yaml")
+        if not idf_file.endswith(".yaml") and not idf_file.endswith(".yml"):
+            raise IDFException(f"IDF file {idf_file} neither endswith .yaml nor endswith .yml")
         super().__init__()
         self.lookup = lookup
         self.file = idf_file
@@ -920,7 +1049,7 @@ class IdfInterface(IdfInterfaceBase):
         # 使用schema校验数据，确保IDF文件符合格式要求，减少程序处理过程中的异常处理
         # 验证失败时抛异常，此处不用处理，由外层处理
         idf = load_yml_with_json_schema_validate(self.file, "/usr/share/litebmc/schema/idf.v1.json")
-        log.info(f"validate {self.file} successfully")
+        log.debug(f"validate {self.file} successfully")
         self.version = idf.get("version")
         self.description = idf.get("description", "")
         # 别名
@@ -974,19 +1103,17 @@ class IdfInterface(IdfInterfaceBase):
         self.structures[self.alias] = intf_stru
 
     def render_dbus_xml(self, template, out_file):
-        fd = open(out_file, "w")
 
         out = self.render(self.lookup, template, intf=self)
         hash = hashlib.sha256()
         hash.update(out.encode('utf-8'))
         self.introspect_xml_sha256 = hash.hexdigest()
         log.info("The sha256sum of interface {} is {}".format(out_file, self.introspect_xml_sha256))
-        fd.write(out)
-        fd.close()
+        with open(out_file, "w") as fd:
+            fd.write(out)
 
     def render_c_source(self, template, out_file):
-        fd = open(out_file, "w")
 
         out = self.render(self.lookup, template, intf=self)
-        fd.write(out)
-        fd.close()
+        with open(out_file, "w") as fd:
+            fd.write(out)

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit/codegen/template/client.c.mako

@@ -104,22 +104,39 @@ int ${class_name}_Call_${method.name}(const ${class_name} *object,
 
 % endfor
 static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque);
+static void _${class_name}_destroy(GclObject *obj);
 
 static GclInterface _${class_name}_interface = {
     .create = _${class_name}_create,
+    .destroy = _${class_name}_destroy,
     .is_remote = 1,
     .name = "${intf.name}",
     .properties = (GclProperty *)&${properties},
     .interface = NULL, /* load from usr/share/dbus-1/interfaces/${intf.name}.xml by gcl_init */
 };
 
+/**
+ * @brief 销毁对象
+ *
+ * @param gcl_obj 待销毁的对象句柄
+ */
+static void _${class_name}_destroy(GclObject *gcl_obj)
+{
+    g_assert(gcl_obj);
+    ${class_name} *obj = (${class_name} *)gcl_obj;
+    g_rec_mutex_clear(obj->_base.lock);
+    g_free(obj->_base.lock);
+    ${intf.alias}_clean(obj);
+    memset(obj, 0, sizeof(${class_name}));
+}
+
 /**
  * @brief 分配对象
  *
  * @param obj_name 对象名，需要由调用者分配内存
  * @param opaque 上层应用需要写入对象的用户数据，由上层应用使用
  */
-GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
+static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
 {
     ${class_name} *obj = g_new0(${class_name}, 1);
     memcpy(obj->_base.magic, GCL_MAGIC, strlen(GCL_MAGIC) + 1);

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit/codegen/template/public.c.mako

@@ -282,7 +282,7 @@ ${name} *${name}_decode_v(GVariant *in, gsize *n)
     }
     ${name} *output = g_new0(${name}, *n);
     while (g_variant_iter_loop(&iter, "s", &str_val)) {
-        for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        for (int i = 0; i < ${len(enum.values.parameters)}; i++) {
             if (g_strcmp0(str_val, _${name}StrMap[i]) == 0) {
                 output[id++] = (${name})i;
             }

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit/codegen/template/server.c.mako

@@ -234,11 +234,13 @@ gboolean ${class_name}_${signal.name}_Signal(const ${class_name} *object, const
 
 % endfor
 static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque);
+static void _${class_name}_destroy(GclObject *obj);
 static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, GclObject *gcl_obj,
     property_reference_loaded ref_loaded, gpointer user_data);
 
 static GclInterface _${class_name}_interface = {
     .create = _${intf.alias}_create,
+    .destroy = _${class_name}_destroy,
     .validate_odf = ${intf.name.replace(".", "_")}_validate_odf,
     .load_from_odf = _load_from_odf,
     .is_remote = 0,
@@ -251,6 +253,7 @@ static GclInterface _${class_name}_interface = {
 static void _load_odf_as_prop_${prop.name}(yaml_document_t *doc, GHashTable *prop_table,
     ${class_name} *obj, property_reference_loaded ref_loaded, gpointer user_data)
 {
+    __attribute__((unused)) gint i = 0;
     const gchar *flags = NULL;
     yaml_node_t *val = g_hash_table_lookup(prop_table, "_${prop.name}_flags");
     if (val && val->type == YAML_SCALAR_NODE) {
@@ -259,6 +262,55 @@ static void _load_odf_as_prop_${prop.name}(yaml_document_t *doc, GHashTable *pro
     val = g_hash_table_lookup(prop_table, "${prop.name}");
     ## validate接口在加载odf前完成属性是否必选校验，此处如果是必选属性一定存在
     if (!val) {
+        ## 设置默认值
+        % if prop.default:
+            % if prop.ctype == "boolean":
+                % if prop.default:
+        obj->${prop.name} = TRUE;
+                % endif
+            % elif prop.ctype in ["byte", "int16", "uint16", "int32", "uint32", "int64", "uint64", "size", "ssize", "double"]:
+                    % if prop.ctype == "uint64":
+        obj->${prop.name} = ${prop.default}UL;
+                    % elif prop.ctype == "int64":
+        obj->${prop.name} = ${prop.default}LL;
+                    % else:
+        obj->${prop.name} = ${prop.default};
+                    % endif
+            % elif prop.ctype in ["object_path", "string", "signature"]:
+        obj->${prop.name} = g_strdup("${prop.default}");
+            % elif prop.ctype == "array[boolean]":
+        i = 0;
+        obj->n_${prop.name} = ${len(prop.default)};
+        obj->${prop.name} = g_new0(gboolean, obj->n_${prop.name});
+                % for val in prop.default:
+                    % if val:
+        obj->${prop.name}[i++] = TRUE;
+                    % else:
+        obj->${prop.name}[i++] = FALSE;
+                    % endif
+                % endfor
+            % elif prop.ctype in ["array[byte]", "array[int16]", "array[uint16]", "array[int32]", "array[uint32]", "array[int64]", "array[uint64]", "array[size]", "array[ssize]", "array[double]"]:
+<% ctype = prop.ctype[6:-1]%>
+        i = 0;
+        obj->n_${prop.name} = ${len(prop.default)};
+        obj->${prop.name} = g_new0(g${ctype},  obj->n_${prop.name});
+                % for val in prop.default:
+                    % if prop.ctype == "array[uint64]":
+        obj->${prop.name}[i++] = ${val}UL;
+                    % elif prop.ctype == "array[int64]":
+        obj->${prop.name}[i++] = ${val}LL;
+                    % else:
+        obj->${prop.name}[i++] = ${val};
+                    % endif
+                % endfor
+            % elif prop.ctype in ["array[object_path]", "array[string]", "array[signature]"]:
+        i = 0;
+        obj->${prop.name} = g_new0(gchar *, ${len(prop.default) + 1});
+                % for val in prop.default:
+        obj->${prop.name}[i++] = g_strdup("${val}");
+                % endfor
+            % endif
+        % endif
         if (flags) {
             ## 属性不存在时传入的value为空，需要开发者在回调函数中完成异常（有flags无属性值）处理
             ref_loaded(obj, &${properties}.${prop.name}, doc, NULL, user_data, flags);
@@ -311,14 +363,31 @@ static void _load_from_odf(yaml_document_t *doc, yaml_node_t *node, GclObject *g
 % endif
 }
 
+/**
+ * @brief 销毁对象
+ *
+ * @param gcl_obj 待销毁的对象句柄
+ */
+static void _${class_name}_destroy(GclObject *gcl_obj)
+{
+    g_assert(gcl_obj);
+    ${class_name} *obj = (${class_name} *)gcl_obj;
+    g_rec_mutex_clear(obj->_base.lock);
+    g_free(obj->_base.lock);
+    ${class_name}_clean(obj);
+    memset(obj, 0, sizeof(${class_name}));
+    g_free(obj);
+}
+
 /**
  * @brief 分配对象
  *
  * @param obj_name 对象名，需要由调用者分配内存
  * @param opaque 上层应用需要写入对象的用户数据，由上层应用使用
  */
-GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
+static GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
 {
+    __attribute__((unused)) gint i = 0;
     ${class_name} *obj = g_new0(${class_name}, 1);
     memcpy(obj->_base.magic, GCL_MAGIC, strlen(GCL_MAGIC) + 1);
     obj->_base.lock = g_new0(GRecMutex, 1);
@@ -326,6 +395,56 @@ GclObject *_${class_name}_create(const gchar *obj_name, gpointer opaque)
     obj->_base.name = obj_name;
     obj->_base.intf = &_${class_name}_interface;
     obj->_base.opaque = opaque;
+    % for prop in intf.properties:
+        % if prop.default:
+            % if prop.ctype == "boolean":
+                % if prop.default:
+    obj->${prop.name} = TRUE;
+                % endif
+            % elif prop.ctype in ["byte", "int16", "uint16", "int32", "uint32", "int64", "uint64", "size", "ssize", "double"]:
+                    % if prop.ctype == "uint64":
+    obj->${prop.name} = ${prop.default}UL;
+                    % elif prop.ctype == "int64":
+    obj->${prop.name} = ${prop.default}LL;
+                    % else:
+    obj->${prop.name} = ${prop.default};
+                    % endif
+            % elif prop.ctype in ["object_path", "string", "signature"]:
+    obj->${prop.name} = g_strdup("${prop.default}");
+            % elif prop.ctype == "array[boolean]":
+    i = 0;
+    obj->n_${prop.name} = ${len(prop.default)};
+    obj->${prop.name} = g_new0(gboolean, obj->n_${prop.name});
+                % for val in prop.default:
+                    % if val:
+    obj->${prop.name}[i++] = TRUE;
+                    % else:
+    obj->${prop.name}[i++] = FALSE;
+                    % endif
+                % endfor
+            % elif prop.ctype in ["array[byte]", "array[int16]", "array[uint16]", "array[int32]", "array[uint32]", "array[int64]", "array[uint64]", "array[size]", "array[ssize]", "array[double]"]:
+<% ctype = prop.ctype[6:-1]%>
+    i = 0;
+    obj->n_${prop.name} = ${len(prop.default)};
+    obj->${prop.name} = g_new0(g${ctype},  obj->n_${prop.name});
+                % for val in prop.default:
+                    % if prop.ctype == "array[uint64]":
+    obj->${prop.name}[i++] = ${val}UL;
+                    % elif prop.ctype == "array[int64]":
+    obj->${prop.name}[i++] = ${val}LL;
+                    % else:
+    obj->${prop.name}[i++] = ${val};
+                    % endif
+                % endfor
+            % elif prop.ctype in ["array[object_path]", "array[string]", "array[signature]"]:
+    i = 0;
+    obj->${prop.name} = g_new0(gchar *, ${len(prop.default) + 1});
+                % for val in prop.default:
+    obj->${prop.name}[i++] = g_strdup("${val}");
+                % endfor
+            % endif
+        % endif
+    % endfor
     return (GclObject *)obj;
 }
 

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit/component/build.py

@@ -85,8 +85,8 @@ class BuildComponent():
         示例: project(gcom LANGUAGES C VERSION 0.1.0)
         """
         try:
-            fp = open("CMakeLists.txt", "r")
-            content = fp.read()
+            with open("CMakeLists.txt", "r") as fp:
+                content = fp.read()
             version = re.search("project\((.*)VERSION ([0-9][1-9]*.[0-9][1-9]*.[0-9][1-9]*)\)", content).group(2)
             return version.strip()
         except Exception as e:

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit/component/test.py

@@ -3,6 +3,7 @@ import shutil
 import re
 import os
 import imp
+import unittest
 from lbkit.component.build import BuildComponent
 from lbkit.component.arg_parser import ArgParser
 from lbkit import errors
@@ -109,7 +110,12 @@ class TestComponent():
             return 0
 
         log.success("call test method...")
-        test.test()
+        ret = test.test()
+        if ret is not None:
+            if isinstance(ret, unittest.TestResult) and (len(ret.errors) > 0 or len(ret.failures) > 0):
+                raise errors.TestException(f"Test failed, ret: {ret}")
+            elif isinstance(ret, int) and ret != 0:
+                raise errors.TestException(f"Test failed, ret: {ret}")
 
         test_src_folder = getattr(test, "test_src_folder", [])
         # 设置ROOTFS_DIR环境变量，为DT测试提供相对路径

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit/errors.py

@@ -72,6 +72,8 @@ class HttpRequestException(Exception):
     def __str__(self):
         return super(HttpRequestException, self).__str__()
 
+class TestException(Exception):
+    pass
 
 class OdfValidateException(Exception):
     def __init__(self, *args, **kwargs):

lbkit-0.5.20/lbkit/helper.py

@@ -0,0 +1,96 @@
+import os
+import yaml
+import unittest
+from xml.dom import minidom, Node
+
+class Helper():
+    @staticmethod
+    def get_node_value(dom: Node, name, default=None):
+        node: minidom.Attr = dom.attributes.get(name)
+        if node is None:
+            if default is None:
+                raise Exception("Parse node failed, abort")
+            return default
+        return node.childNodes[0].nodeValue.strip()
+
+    def read_yaml(file: str, key, default=None):
+        if not os.path.isfile(file):
+            return default
+        fd = open(file, "r");
+        try:
+            data = yaml.load(fd, Loader=yaml.FullLoader)
+            for split in key.split("/", -1):
+                data = data.get(split)
+                if data is None:
+                    return default
+            return data
+        except:
+            return default
+
+
+generate_sig_chars = [
+    "y", "b", "n", "q", "i", "u", "x", "t", "h",
+    "d", "v", "s", "o", "g"]
+
+
+class SigInvalidException(Exception):
+    pass
+
+def _validate_glib_signature(sig_str, sigs):
+    if len(sigs) == 0:
+        raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+    if sigs[0] in generate_sig_chars:
+        if len(sigs) > 1:
+            return _validate_glib_signature(sig_str, sigs[1:])
+        return
+    if sigs[0] == "a":
+        return _validate_glib_signature(sig_str, sigs[1:])
+    if sigs[0] in ["(", "{"]:
+        next_chr = ")"
+        if sigs[0] == "{":
+            next_chr = "}"
+
+        cnt = 0
+        next_pos = -1
+        for i, c in enumerate(sigs):
+            if c == sigs[0]:
+                cnt += 1
+            elif c == next_chr:
+                cnt -= 1
+            if cnt == 0:
+                next_pos = i
+                break
+        # 未找到下一个右括号
+        if next_pos == -1:
+            raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+        # 元组()之间可以为空
+        if sigs[0] == '(' and next_pos == 1:
+            return
+        if sigs[0] == "{":
+            # 字典至少需要两个字符
+            if next_pos < 3:
+                raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+            # 字典第一个签名必须是简单类型
+            if sigs[1] not in generate_sig_chars:
+                raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+        _validate_glib_signature(sig_str, sigs[1:next_pos])
+        sigs = sigs[next_pos + 1:]
+        if not sigs:
+            return
+        _validate_glib_signature(sig_str, sigs)
+        return
+
+    # '}' 和 ')'及其它字符起始的认为是非法字符
+    raise SigInvalidException(f"String {sig_str} is not a valid signature str")
+
+
+def validate_glib_signature(sig_str):
+    _validate_glib_signature(sig_str, list(sig_str))
+
+
+class TestSignatureValidateClass(unittest.TestCase):
+    def test_validate_glib_signature(self):
+        validate_glib_signature("as")
+
+if __name__ == "__main__":
+    unittest.main()

{lbkit-0.5.18 → lbkit-0.5.20/lbkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lbkit
-Version: 0.5.18
+Version: 0.5.20
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit.egg-info/SOURCES.txt

@@ -45,4 +45,7 @@ lbkit/integration/build_prepare.py
 lbkit/integration/build_rootfs.py
 lbkit/integration/config.py
 lbkit/integration/task.py
-lbkit/integration/template/conanfile.py.mako
+lbkit/integration/template/conanfile.py.mako
+test/__init__.py
+test/test_codegen.py
+test/test_helper.py

{lbkit-0.5.18 → lbkit-0.5.20}/lbkit.egg-info/top_level.txt

@@ -1 +1,2 @@
 lbkit
+test