lbkit 0.7.2__tar.gz → 0.7.4__tar.gz

{lbkit-0.7.2/lbkit.egg-info → lbkit-0.7.4}/PKG-INFO

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

lbkit-0.7.4/lbkit/__init__.py

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

{lbkit-0.7.2 → lbkit-0.7.4}/lbkit/codegen/codegen.py

@@ -7,6 +7,7 @@ import json
 import yaml
 import argparse
 from lbkit.codegen.idf_interface import IdfInterface
+from lbkit.utils.version import Version, X_VER
 
 from mako.lookup import TemplateLookup
 from lbkit.log import Logger
@@ -17,13 +18,36 @@ from lbkit.misc import SmartFormatter
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
 log = Logger("codegen")
 
-__version__=4
+# 历史自动生成版本号，计划用于用于生成代码稳定性测试
+# TODO： 支持生成代码稳定性测试，确保生成的代码一致性
+history_versions = {
+    "5.0": "简化枚举变更在接口间传递时的字符串定义"
+}
+__version__=Version("5.0")
+
+
+def version_check(ver_str: str):
+    ver = Version(ver_str)
+    if history_versions.get(ver_str):
+        return ver
+    found = False
+    if ver.minor == X_VER:
+        major_str = str(ver.major) + "."
+        for v, _ in history_versions.items():
+            if v.startswith(major_str):
+                found = True
+                break
+    if not found:
+        log.error(f"Unkonw codegen version {ver_str}, supported versions:")
+        for ver, msg in history_versions.items():
+            log.error(f"    {ver}: {msg}")
+        raise Exception("Unkonw codegen version get")
+    return ver
 
 class CodeGen(object):
     def __init__(self, args):
         self.args = args
         self.codegen_version = __version__
-        pass
 
     def _gen(self, idf_file, directory="."):
         directory = os.path.realpath(directory)
@@ -32,12 +56,12 @@ class CodeGen(object):
         os.makedirs(os.path.join(directory, "client"), exist_ok=True)
         interface = self.get_interface(idf_file)
         out_file = os.path.join(directory, "public", interface.name + ".xml")
-        interface.render_dbus_xml("interface.introspect.xml.mako", out_file, self.codegen_version)
+        interface.render_dbus_xml("interface.introspect.xml.mako", out_file)
         for code_type in ["server", "client", "public"]:
             out_file = os.path.join(directory, code_type, interface.name + ".h")
-            interface.render_c_source(code_type + ".h.mako", out_file, self.codegen_version)
+            interface.render_c_source(code_type + ".h.mako", out_file)
             out_file = os.path.join(directory, code_type, interface.name + ".c")
-            interface.render_c_source(code_type + ".c.mako", out_file, self.codegen_version)
+            interface.render_c_source(code_type + ".c.mako", out_file)
         json_file = os.path.join(directory, "package.yml")
         data = {
             "version": interface.version,
@@ -55,7 +79,7 @@ class CodeGen(object):
 
     def get_interface(self, idf_file):
         lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
-        return IdfInterface(lookup, idf_file)
+        return IdfInterface(lookup, idf_file, self.codegen_version)
 
     def run(self):
         """
@@ -67,12 +91,16 @@ class CodeGen(object):
                                          prog="lbkit gen",
                                          formatter_class=SmartFormatter)
         # 默认的自动生成工具版本号为2
-        parser.add_argument("-cv", "--codegen_version", help=f'''must less than or equal to {__version__}, default: 2
+        parser.add_argument("-cv", "--codegen_version", help=f'''must less than or equal to {__version__.str}, default: {__version__.str}
+                            format: major.version
+                            for example: 1.3、2.4、3.3
+
                             description of changes:
-                            3: compatible with lb_base/0.7.x
-                            2: compatible with lb_base/0.6.x
+                            4.x: compatible with lb_base/0.8.x
+                            3.x: compatible with lb_base/0.7.x
+                            2.x: compatible with lb_base/0.6.x
                             ''',
-                            type=int, default=2)
+                            type=str, default=__version__.str)
         parser.add_argument("-d", "--directory", help='generate code directory', default=".")
         group2 = parser.add_argument_group('cdf file', 'Generate code using the specified CDF file')
         group2.add_argument("-c", "--cdf_file", help='component description file, default metadata/package.yml', default=None)
@@ -86,7 +114,9 @@ class CodeGen(object):
                 raise ArgException(f"argument -c/--cdf_file: {args.cdf_file} not exist")
             configs = Helper.read_yaml(args.cdf_file, "codegen", [])
             # 为保障兼容，package.yml未指定版本号的，默认使用2，该版本配套lb_base/0.6.0版本，其LBProperty无set/get成员
-            self.codegen_version = Helper.read_yaml(args.cdf_file, "codegen_version", 2)
+            ver_str = Helper.read_yaml(args.cdf_file, "codegen_version", args.codegen_version)
+            version_check(ver_str)
+            self.codegen_version = Version(ver_str)
             for cfg in configs:
                 file = cfg.get("file")
                 if file is None:
@@ -101,15 +131,17 @@ class CodeGen(object):
                 outdir = cfg.get("outdir", os.getcwd())
                 self._gen(file, outdir)
             return
+        else:
+            version_check(args.codegen_version)
+            self.codegen_version = Version(args.codegen_version)
 
         intf_file = args.idf_file
         if not intf_file:
             raise ArgException(f"argument error, arguments -c/--cdf_file and -i/--idf_file are not set")
         if not os.path.isfile(intf_file):
             raise ArgException(f"argument -i/--idf_file: {args.idf_file} not exist")
-        if args.codegen_version > __version__ or args.codegen_version <= 0:
-            raise ArgException(f"argument -v/--codegen_version: validate failed, must less than or equal to {__version__} and bigger than 0")
-        self.codegen_version = args.codegen_version
+        if self.codegen_version.bt(__version__.str):
+            raise ArgException(f"argument -cv/--codegen_version: validate failed, must less than or equal to {__version__.str}")
         out_dir = os.path.join(os.getcwd(), args.directory)
         if not intf_file.endswith(".yaml"):
             raise ArgException(f"The IDF file ({intf_file}) not endswith .yaml")

{lbkit-0.7.2 → lbkit-0.7.4}/lbkit/codegen/idf_interface.py

@@ -9,6 +9,7 @@ from lbkit.codegen.ctype_defination import CTYPE_OBJS, RefObjArrayValidator, Ref
 from lbkit.misc import load_yml_with_json_schema_validate
 from lbkit.errors import OdfValidateException, LiteBmcException
 from lbkit.helper import SigInvalidException, validate_glib_signature
+from lbkit.utils.version import Version
 
 log = Logger("gen_interface")
 
@@ -35,6 +36,7 @@ class IdfInterfaceBase(Renderer):
         self.description = None
         self.version = None
         self.alias = None
+        self.codegen_version: Version = None
 
 class IdfAnnotation():
     def __init__(self, name, value):
@@ -929,7 +931,10 @@ class IdfEnumeration(IdfBase):
     def odf_schema(self):
         values = []
         for prop in self.values.parameters:
-            val = self.intf.name + "." + self.name + "." + prop.name
+            if self.intf.codegen_version.lt("5.0"):
+                val = self.intf.name + "." + self.name + "." + prop.name
+            else:
+                val = prop.name
             values.append(val)
 
         odf = {
@@ -1030,7 +1035,7 @@ class IdfDictionary():
 
 
 class IdfInterface(IdfInterfaceBase):
-    def __init__(self, lookup, idf_file):
+    def __init__(self, lookup, idf_file, codegen_version: Version):
         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__()
@@ -1049,6 +1054,7 @@ class IdfInterface(IdfInterfaceBase):
         self.description = None
         self.version = None
         self.alias = None
+        self.codegen_version = codegen_version
         self.load_elements()
 
     @cached_property
@@ -1069,7 +1075,7 @@ class IdfInterface(IdfInterfaceBase):
             if not realpath:
                 raise FileNotFoundError(f"Dependency interface {intf} not exist")
             log.debug(f"Found dependency interface: {realpath}")
-            deps[intf] = (IdfInterface(self.lookup, realpath))
+            deps[intf] = (IdfInterface(self.lookup, realpath, self.codegen_version))
         return deps
 
     @cached_property
@@ -1233,8 +1239,8 @@ class IdfInterface(IdfInterfaceBase):
         intf_stru = IdfStructure(self, idf, propety_key="properties")
         self.structures[self.alias] = intf_stru
 
-    def render_dbus_xml(self, template, out_file, codegen_version):
-        out = self.render(self.lookup, template, intf=self, codegen_version=codegen_version)
+    def render_dbus_xml(self, template, out_file):
+        out = self.render(self.lookup, template, intf=self, codegen_version=self.codegen_version)
         hash = hashlib.sha256()
         hash.update(out.encode('utf-8'))
         self.introspect_xml_sha256 = hash.hexdigest()
@@ -1242,9 +1248,9 @@ class IdfInterface(IdfInterfaceBase):
         with open(out_file, "w") as fd:
             fd.write(out)
 
-    def render_c_source(self, template, out_file, codegen_version):
+    def render_c_source(self, template, out_file):
 
-        out = self.render(self.lookup, template, intf=self, codegen_version=codegen_version)
+        out = self.render(self.lookup, template, intf=self, codegen_version=self.codegen_version)
         with open(out_file, "w") as fd:
             fd.write(out)
 

{lbkit-0.7.2 → lbkit-0.7.4}/lbkit/codegen/template/client.c.mako

@@ -192,7 +192,7 @@ ${class_name}_Properties *${class_name}_properties(void)
     return &${properties};
 }
 
-% if codegen_version >= 4:
+% if codegen_version.be("4.0"):
 ${class_name} ${class_name}_get(const gchar *well_known, const gchar *name)
 {
     return lb_impl._cli_get(&_${class_name}_interface, well_known, name);

{lbkit-0.7.2 → lbkit-0.7.4}/lbkit/codegen/template/client.h.mako

@@ -110,7 +110,7 @@ ${class_name}_Properties *${class_name}_properties(void);
 LBInterface *${class_name}_interface(void);
 #define ${hump2underline(class_name).upper()}    ${class_name}_interface()
 
-% if codegen_version >= 4:
+% if codegen_version.be("4.0"):
 /* notes: 对象变更加回调函数 */
 typedef void (*${class_name}_on_changed_hook)(${class_name} lb_obj, gpointer user_data);
 /* notes: 属性变更后回调，远程对象或本地对象变更后都会调用 */

{lbkit-0.7.2 → lbkit-0.7.4}/lbkit/codegen/template/public.c.mako

@@ -265,6 +265,49 @@ gboolean _validate_odf_as_struct_${name}_v(yaml_document_t *doc, yaml_node_t *no
 
 %endfor
 % for name, enum in intf.enumerations.items():
+% if codegen_version.be("5.0"):
+## 枚举序列化和反序列化函数
+static const gchar *_${name}StrMap[] = {
+% for value in enum.values.parameters:
+    "${value.name}",
+% endfor
+};
+
+const gchar *${name}_as_string(${name} value)
+{
+    if (value >= _${name}_Invalid) {
+        return "_Invalid";
+    }
+    return _${name}StrMap[value];
+}
+
+/* ${name}枚举类型序列化（enum转string）函数 */
+GVariant *${name}_encode(${name} value)
+{
+    ## 非法值返回com.litebmc.Errors.Enum.Invalid
+    if (value > ${name}_${enum.values.parameters[len(enum.values.parameters) - 1].name}) {
+        return g_variant_new_string("_Invalid");
+    }
+    return g_variant_new_string(_${name}StrMap[value]);
+}
+
+/* ${name}枚举类型反序列化（string转enum）函数 */
+${name} ${name}_decode(GVariant *in)
+{
+    if (!in) {
+        return _${name}_Invalid;
+    }
+
+    const gchar *in_val = g_variant_get_string(in, NULL);
+    for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        if (g_strcmp0(in_val, _${name}StrMap[i]) == 0) {
+            return (${name})i;
+        }
+    }
+    return _${name}_Invalid;
+}
+
+% else:
 ## 枚举序列化和反序列化函数
 static const gchar *_${name}StrMap[] = {
 % for value in enum.values.parameters:
@@ -306,6 +349,7 @@ ${name} ${name}_decode(GVariant *in)
     return _${name}Invalid;
 }
 
+% endif
 /* ${name}枚举类型序列化（enum转string）函数 */
 GVariant *${name}_encode_v(const ${name} *values, gsize n)
 {
@@ -844,7 +888,7 @@ static GDBusPropertyInfo ${class_name}_property_${prop.name} =
     % endif
 % endfor
 ## 只有自动生成工具版本号大于等于3的才会生成get和set方法
-% if codegen_version >= 3:
+% if codegen_version.be("3.0"):
 % if len(intf.properties):
 static LBBase *_get_real_object(${class_name} object)
 {
@@ -895,7 +939,7 @@ static ${class_name}_Properties _${class_name}_properties =
         .info = NULL, /* load from /usr/share/dbus-1/interfaces/${intf.name} by lb_init */
         % endif
         .offset = offsetof(struct _${class_name}, ${prop.name}),
-% if codegen_version >= 3:
+% if codegen_version.be("3.0"):
         .flags = ${prop.desc_flags},
         .set = ${class_name}_set_${prop.name}_variant,
         .get = ${class_name}_get_${prop.name}_variant

{lbkit-0.7.2 → lbkit-0.7.4}/lbkit/codegen/template/public.h.mako

@@ -60,7 +60,11 @@ typedef enum {
     % for value in enum.values.parameters:
     ${name}_${value.name},
     % endfor
+% if codegen_version.be("5.0"):
+    _${name}_Invalid,
+% else:
     _${name}Invalid,
+% endif
 } ${name};
 const gchar *${name}_as_string(${name} value);
 

{lbkit-0.7.2 → lbkit-0.7.4}/lbkit/codegen/template/server.c.mako

@@ -86,6 +86,19 @@ struct _${name} **_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node
 % for name, enum in intf.enumerations.items():
 ${name} _load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node)
 {
+% if codegen_version.be("5.0"):
+    g_assert(node->type == YAML_SCALAR_NODE);
+    if (node->type != YAML_SCALAR_NODE) {
+        return _${name}_Invalid;
+    }
+
+    for (int i = 0; i <= ${len(enum.values.parameters)}; i++) {
+        if (g_strcmp0((const gchar *)node->data.scalar.value, ${name}_as_string(i)) == 0) {
+            return (${name})i;
+        }
+    }
+    return _${name}_Invalid;
+% else:
     g_assert(node->type == YAML_SCALAR_NODE);
     if (node->type != YAML_SCALAR_NODE) {
         return _${name}Invalid;
@@ -97,6 +110,7 @@ ${name} _load_odf_as_${name}(yaml_document_t *doc, yaml_node_t *node)
         }
     }
     return _${name}Invalid;
+% endif
 }
 
 ${name} *_load_odf_as_${name}_v(yaml_document_t *doc, yaml_node_t *node, gsize *n)
@@ -468,7 +482,7 @@ ${class_name}_Properties *${class_name}_properties(void)
     return &${properties};
 }
 
-% if codegen_version >= 4:
+% if codegen_version.be("4.0"):
 ${class_name} ${class_name}_get(const gchar *name)
 {
     return lb_impl._get(&_${class_name}_interface, name);

{lbkit-0.7.2 → lbkit-0.7.4}/lbkit/codegen/template/server.h.mako

@@ -56,7 +56,7 @@ ${class_name}_Properties *${class_name}_properties(void);
 
 #define ${hump2underline(class_name).upper()} ${class_name}_interface()
 
-% if codegen_version >= 4:
+% if codegen_version.be("4.0"):
 /* notes: 对象变更加回调函数 */
 typedef void (*${class_name}_on_changed_hook)(${class_name} lb_obj, gpointer user_data);
 /* notes: 属性变更后回调，远程对象或本地对象变更后都会调用 */

lbkit-0.7.4/lbkit/utils/version.py

@@ -0,0 +1,41 @@
+"""环境准备"""
+import re
+
+X_VER = 0x7fff_ffff
+
+class Version():
+    def __init__(self, ver_str):
+        if not re.match("^([0-9]|([1-9][0-9]*))\\.(x|[0-9]|([1-9][0-9]*))$", ver_str):
+            raise Exception("Version string {ver_str} not match with regex ^([0-9]|([1-9][0-9]*))\\.([0-9]|([1-9][0-9]*))$")
+        chunks = ver_str.split(".")
+        self.major = int(chunks[0])
+        if chunks[1] == "x":
+            self.minor = X_VER
+        else:
+            self.minor = int(chunks[1])
+        self.str = ver_str
+
+    def bt(self, next_ver):
+        next = Version(next_ver)
+        if self.major > next.major or (self.major == next.major and (self.minor > next.minor and self.minor != X_VER)):
+            return True
+        return False
+
+    def be(self, next_ver):
+        next = Version(next_ver)
+        if self.major > next.major or (self.major == next.major and self.minor >= next.minor):
+            return True
+        return False
+
+    def lt(self, next_ver):
+        next = Version(next_ver)
+        if self.major < next.major or (self.major == next.major and (self.minor < next.minor and next.minor != X_VER and next.minor != X_VER)):
+            return True
+        return False
+
+    def le(self, next_ver):
+        next = Version(next_ver)
+        if self.major < next.major or (self.major == next.major and (self.minor <= next.minor or self.minor == X_VER)):
+            return True
+        return False
+

{lbkit-0.7.2 → lbkit-0.7.4/lbkit.egg-info}/PKG-INFO

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

{lbkit-0.7.2 → lbkit-0.7.4}/lbkit.egg-info/SOURCES.txt

@@ -49,6 +49,7 @@ lbkit/integration/task.py
 lbkit/integration/template/conanfile.py.mako
 lbkit/integration/template/rootfs.py.mako
 lbkit/utils/__init__.py
+lbkit/utils/version.py
 lbkit/utils/images/__init__.py
 lbkit/utils/images/emmc.py
 test/__init__.py

{lbkit-0.7.2 → lbkit-0.7.4}/test/test_codegen.py

@@ -4,8 +4,10 @@ import os
 import tracemalloc
 
 tracemalloc.start()
-from lbkit.codegen.idf_interface import IdfInterface, IdfProperty
+from lbkit.codegen.idf_interface import IdfInterface
 from lbkit import errors
+from lbkit.codegen.codegen import __version__ as codegen_version
+from lbkit.utils.version import Version
 
 schema_dir = os.path.realpath(os.path.join(os.getcwd(), "..", "schema"))
 
@@ -86,39 +88,39 @@ class TestCodeGenClass(unittest.TestCase):
 
     def test_validate_default_bool(self):
         self.validate_boolean("b", "boolean", "true")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "false")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "False")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "True")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "ONsdf")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "boolean", "asdaffa")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_default_array_bool(self):
         self.validate_boolean("b", "array[boolean]", "[false, true]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.validate_boolean("b", "array[boolean]", "[on, 1]")
         # boolean值比较特殊，由json schema校验验证
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def validate_number(self, name, type):
         self.mk_interface_with_number_property(name, type, "100", "1", "1")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, type, "100", "1", "100")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, type, "100", "1", "0")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, type, "100", "1", "101")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_default_byte(self):
         self.validate_number("y", "byte")
@@ -152,15 +154,15 @@ class TestCodeGenClass(unittest.TestCase):
 
     def validate_array_number(self, name, type):
         self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[1, 1]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[100, 100]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[0, 0]")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_number_property(name, f"array[{type}]", "100", "1", "[101, 101]")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_default_array_byte(self):
         self.validate_array_number("y", "byte")
@@ -195,88 +197,131 @@ class TestCodeGenClass(unittest.TestCase):
     def test_validate_array_double(self):
         self.mk_interface_with_double_property("double", f"array[double]", "[1, 1]", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", f"array[double]", "[100, 100]", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", f"array[double]", "[0.9, 0.9]", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", f"array[double]", "[100.1, 100.1]", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_double(self):
         self.mk_interface_with_double_property("double", "double", "1", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", "double", "100", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", "double", "0.9", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_double_property("double", "double", "100.1", exclusive_max="100", exclusive_min="1")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_string(self):
         self.mk_interface_with_string_property("string", "string", None, "as")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "as")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "ass")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "asss")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "a")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "string", "^a[s]{1,2}$", "0.123")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_array_string(self):
         self.mk_interface_with_string_property("string", "array[string]", None, "[as, as]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[as, as]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[ass, ass]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[asss, asss]")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[a, a]")
         with self.assertRaises(errors.OdfValidateException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("string", "array[string]", "^a[s]{1,2}$", "[0.123, 0.123]")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_object_path(self):
         self.mk_interface_with_string_property("object_path", "object_path", None, "/as")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "object_path", None, "/a/s")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "object_path", None, "a/s")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "object_path", None, "/a/s/")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
 
     def test_validate_array_object_path(self):
         self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[/as, /as]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[/a/s, /a]")
-        IdfInterface(None, self.tmp_file)
+        IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[a/s, a/s]")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
         self.mk_interface_with_string_property("object_path", "array[object_path]", None, "[/a/s/, /a/s/]")
         with self.assertRaises(errors.PackageConfigException):
-            IdfInterface(None, self.tmp_file)
+            IdfInterface(None, self.tmp_file, codegen_version)
+
+
+class TestVersionClass(unittest.TestCase):
+    def test_version_bt(self):
+        self.assertTrue(Version("5.2").bt("5.1"))
+        self.assertTrue(Version("6.2").bt("5.1"))
+        self.assertTrue(Version("6.2").bt("5.2"))
+        self.assertTrue(Version("6.2").bt("5.3"))
+        self.assertFalse(Version("5.x").bt("5.1"))
+        self.assertFalse(Version("5.x").bt("5.x"))
+        self.assertFalse(Version("5.1").bt("5.2"))
+        self.assertFalse(Version("5.2").bt("5.2"))
+        self.assertFalse(Version("4.2").bt("5.2"))
+        self.assertFalse(Version("4.x").bt("5.2"))
+        self.assertFalse(Version("4.x").bt("5.x"))
+
+    def test_version_be(self):
+        self.assertTrue(Version("5.2").be("5.2"))
+        self.assertTrue(Version("5.x").be("5.3"))
+        self.assertTrue(Version("5.x").be("5.x"))
+        self.assertFalse(Version("5.1").be("5.x"))
+
+    def test_version_le(self):
+        self.assertFalse(Version("5.2").le("5.1"))
+        self.assertFalse(Version("6.2").le("5.1"))
+        self.assertFalse(Version("6.2").le("5.2"))
+        self.assertFalse(Version("6.2").le("5.3"))
+        self.assertTrue(Version("5.x").le("5.1"))
+        self.assertTrue(Version("5.x").le("5.x"))
+        self.assertTrue(Version("5.1").le("5.2"))
+        self.assertTrue(Version("5.2").le("5.2"))
+        self.assertTrue(Version("4.2").le("5.2"))
+        self.assertTrue(Version("4.x").le("5.2"))
+        self.assertTrue(Version("4.x").le("5.x"))
+
+    def test_version_lt(self):
+        self.assertFalse(Version("5.2").lt("5.2"))
+        self.assertFalse(Version("5.x").lt("5.3"))
+        self.assertFalse(Version("5.x").lt("5.x"))
+        self.assertFalse(Version("5.1").lt("5.x"))
+        self.assertTrue(Version("5.1").lt("5.2"))
+        self.assertTrue(Version("4.3").lt("5.2"))
+        self.assertTrue(Version("4.3").lt("5.3"))
 
 
 if __name__ == "__main__":

lbkit-0.7.2/lbkit/__init__.py

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