lbkit 0.7.4__tar.gz → 0.8.0__tar.gz

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

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

lbkit-0.8.0/lbkit/__init__.py

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

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

@@ -3,6 +3,7 @@
 """
 import os
 import sys
+import re
 import json
 import yaml
 import argparse
@@ -18,50 +19,69 @@ from lbkit.misc import SmartFormatter
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
 log = Logger("codegen")
 
+
+class CodeGenHistory():
+    def __init__(self, lb_base: str, description: str):
+        self.lb_base = lb_base
+        self.description = description
+
 # 历史自动生成版本号，计划用于用于生成代码稳定性测试
 # TODO： 支持生成代码稳定性测试，确保生成的代码一致性
 history_versions = {
-    "5.0": "简化枚举变更在接口间传递时的字符串定义"
+    "5.0": CodeGenHistory("lb_base/[>=0.8.1 <0.9.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:
+    if not re.match("^([0-9]|([1-9][0-9]*))\\.([0-9]|([1-9][0-9]*))$", ver_str):
+        raise Exception(f"Version string {ver_str} not match with regex ^([0-9]|([1-9][0-9]*))\\.([0-9]|([1-9][0-9]*))$")
+    if "x" not in ver_str:
+        return ver_str
+    if not history_versions.get(ver_str):
         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
+        raise Exception(f"Can't found the valid version for {ver_str}")
+
+
+def codegen_version_arg(parser: argparse.ArgumentParser, default=__version__.str, short_arg="-cv", full_arg="--codegen_version"):
+    # 默认的自动生成工具版本号为2
+    help=f'''must less than or equal to {__version__.str}, default: {default}
+
+        codegen versions:
+        '''
+    for ver, detail in history_versions.items():
+        help += f"- {ver}: compatible with {detail.lb_base}, {detail.description}\n"
+    parser.add_argument(short_arg, full_arg, help=help, type=str, default=__version__.str)
+
 
 class CodeGen(object):
     def __init__(self, args):
         self.args = args
         self.codegen_version = __version__
 
-    def _gen(self, idf_file, directory="."):
+    def _gen(self, idf_file, directory=".", code_type="all"):
         directory = os.path.realpath(directory)
-        os.makedirs(os.path.join(directory, "public"), exist_ok=True)
-        os.makedirs(os.path.join(directory, "server"), exist_ok=True)
-        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)
-        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)
-            out_file = os.path.join(directory, code_type, interface.name + ".c")
-            interface.render_c_source(code_type + ".c.mako", out_file)
+        code_types = ["server", "client", "public"]
+        if code_type != "all":
+            code_types = [code_type]
+        for ct in code_types:
+            os.makedirs(os.path.join(directory, ct), exist_ok=True)
+            out_file = os.path.join(directory, ct, interface.name + ".xml")
+            interface.render_dbus_xml("interface.introspect.xml.mako", out_file)
+            out_file = os.path.join(directory, ct, interface.name + ".h")
+            interface.render_c_source(ct + ".h.mako", out_file)
+            out_file = os.path.join(directory, ct, interface.name + ".c")
+            interface.render_c_source(ct + ".c.mako", out_file)
+            if "server" == ct:
+                # 生成接口schema文件
+                odf_file = os.path.join(directory, "server", "schema", f"{interface.name}.json")
+                os.makedirs(os.path.dirname(odf_file), exist_ok=True)
+                odf_data = interface.odf_schema
+                with open(odf_file, "w", encoding="utf-8") as fp:
+                    json.dump(odf_data, fp, sort_keys=False, indent=4)
         json_file = os.path.join(directory, "package.yml")
         data = {
             "version": interface.version,
@@ -70,13 +90,6 @@ class CodeGen(object):
         with open(json_file, "w", encoding="utf-8") as fp:
             yaml.dump(data, fp, encoding='utf-8', allow_unicode=True)
 
-        # 生成接口schema文件
-        odf_file = os.path.join(directory, "server", "schema", f"{interface.name}.json")
-        os.makedirs(os.path.dirname(odf_file), exist_ok=True)
-        odf_data = interface.odf_schema
-        with open(odf_file, "w", encoding="utf-8") as fp:
-            json.dump(odf_data, fp, sort_keys=False, indent=4)
-
     def get_interface(self, idf_file):
         lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
         return IdfInterface(lookup, idf_file, self.codegen_version)
@@ -90,18 +103,9 @@ class CodeGen(object):
         parser = argparse.ArgumentParser(description=self.run.__doc__,
                                          prog="lbkit gen",
                                          formatter_class=SmartFormatter)
-        # 默认的自动生成工具版本号为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:
-                            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=str, default=__version__.str)
+        codegen_version_arg(parser)
         parser.add_argument("-d", "--directory", help='generate code directory', default=".")
+        parser.add_argument("-t", "--codetype", help='code type, default: all', default="all", choices=["public", "server", "client", "all"])
         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)
         group1 = parser.add_argument_group('idf file', 'Generate code using the specified IDF file')
@@ -150,7 +154,7 @@ class CodeGen(object):
         if not os.path.isdir(out_dir):
             log.warning(f"Directory {args.directory} not exist, try create")
             os.makedirs(out_dir)
-        self._gen(intf_file, out_dir)
+        self._gen(intf_file, out_dir, args.codetype)
 
 if __name__ == "__main__":
     gen = CodeGen(sys.argv)

{lbkit-0.7.4 → lbkit-0.8.0}/lbkit/codegen/ctype_defination.py

@@ -4,20 +4,19 @@ from lbkit.errors import OdfValidateException
 
 
 class IdfValidator():
-    validator = {}
-    name = ""
+    def __init__(self):
+        self.validator = {}
+        self.name = ""
 
     def set_validator(self, value, name):
         self.validator = value
         self.name = name
 
     def odf_validate(self):
-        idf_validator = idf_validator
         return []
 
     def odf_schema(self, allow_ref):
         allow_ref = allow_ref
-        idf_validator = idf_validator
         return None
 
 
@@ -73,9 +72,6 @@ class BoolArrayValidator(BoolValidator):
 
 
 class IntegerValidator(IdfValidator):
-    maximum = sys.maxsize * 2
-    minimum = -(sys.maxsize + 1) * 2
-
     def __init__(self, max, min, signed=False):
         self.maximum = max
         self.minimum = min
@@ -188,13 +184,11 @@ class IntegerArrayValidator(IntegerValidator):
 
 
 class FloatValidator(IdfValidator):
-    maximum = sys.float_info.max
-    minimum = -sys.float_info.max
-
-    exclusive_max = None
-    exclusive_min = None
-
     def __init__(self):
+        self.maximum = sys.float_info.max
+        self.minimum = -sys.float_info.max
+        self.exclusive_max = None
+        self.exclusive_min = None
         self.max_key = "maximum"
         self.max_val = self.maximum
         self.min_key = "minimum"
@@ -294,7 +288,6 @@ class FloatArrayValidator(FloatValidator):
 
 
 class StringValidator(IdfValidator):
-    pattern = None
     def __init__(self, pattern):
         self.pattern = pattern
         super().__init__()

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

@@ -240,7 +240,7 @@ class IdfCtypeRender():
             if "refobj" in self.flags:
                 valiator = RefObjValidator()
                 return valiator.odf_schema(allow_ref)
-            ctype_obj = CTYPE_OBJS.get(self.ctype)
+            ctype_obj = copy.deepcopy(CTYPE_OBJS.get(self.ctype))
             validator = ctype_obj.validator
             if validator_cfg:
                 validator.set_validator(validator_cfg, self.name)
@@ -1067,13 +1067,17 @@ class IdfInterface(IdfInterfaceBase):
             realpath = None
             while cwd != "/":
                 tmp_path = os.path.join(cwd, intf_path)
+                if os.path.isfile(tmp_path):
+                    realpath = tmp_path
+                    break
+                tmp_path = os.path.join(cwd, intf + ".yaml")
                 if os.path.isfile(tmp_path):
                     realpath = tmp_path
                     break
                 cwd = os.path.dirname(cwd)
 
             if not realpath:
-                raise FileNotFoundError(f"Dependency interface {intf} not exist")
+                raise FileNotFoundError(f"Dependency interface {intf} not exist, cwd: {os.getcwd()}")
             log.debug(f"Found dependency interface: {realpath}")
             deps[intf] = (IdfInterface(self.lookup, realpath, self.codegen_version))
         return deps

{lbkit-0.7.4 → lbkit-0.8.0}/lbkit/component/arg_parser.py

@@ -1,7 +1,8 @@
 """组件公共参数"""
 import argparse
 import os
-from argparse import RawTextHelpFormatter
+from lbkit.misc import SmartFormatter
+from lbkit.codegen.codegen import codegen_version_arg
 
 cwd = os.getcwd()
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
@@ -11,7 +12,7 @@ class ArgParser():
     @staticmethod
     def new(add_help=True):
         parser = argparse.ArgumentParser(
-            description="Build component", add_help=add_help, formatter_class=RawTextHelpFormatter)
+            description="Build component", add_help=add_help, formatter_class=SmartFormatter)
         parser.add_argument("-t", "--build_type", default="Debug",
                             help="Build type(Same as conan's settings.build_type), only Debug,Release can be accepted")
         parser.add_argument("-pr", "--profile", default="default",
@@ -35,4 +36,6 @@ class ArgParser():
         parser.add_argument(
             "-c", "--channel", help='Provide a channel if not specified in mds/package.yml\ndefault value: dev', default="dev")
         parser.add_argument('-o','--pkg_options', action='append', help='Define options values (host machine), e.g.: -o pkg/*:shared=True', required=False, default=[])
+        # 默认的自动生成工具版本号为
+        codegen_version_arg(parser, None)
         return parser

{lbkit-0.7.4 → lbkit-0.8.0}/lbkit/component/build.py

@@ -83,6 +83,8 @@ class BuildComponent():
             self.base_cmd += f" -o {self.name}/*:test=True"
         for pkg_option in self.options.pkg_options:
             self.base_cmd += " -o " + pkg_option
+        if self.options.codegen_version:
+            self.base_cmd += f" -o */*:codegen_version={self.options.codegen_version}"
 
     def get_package_version(self):
         """

{lbkit-0.7.4 → lbkit-0.8.0}/lbkit/component/test.py

@@ -75,14 +75,17 @@ class TestComponent():
         res = tool.run(cmd)
         files = res.stdout.strip().split("\n")
         ld_library_path = os.environ.get("LD_LIBRARY_PATH", "").strip()
-        library_path = []
-        if ld_library_path != "":
-            library_path = ld_library_path.split(":")
+        paths = []
+        for path in ld_library_path.split(":"):
+            if not path:
+                continue
+            if not ".temp/rootfs" in path:
+                paths.append(path)
         for file in files:
             dir = os.path.dirname(file)
-            if dir not in library_path:
-                library_path.append(dir)
-        os.environ["LD_LIBRARY_PATH"] = ":".join(library_path)
+            if dir not in paths:
+                paths.append(dir)
+        os.environ["LD_LIBRARY_PATH"] = ":".join(paths)
 
     def run(self):
         # 构建组件

{lbkit-0.7.4 → lbkit-0.8.0}/lbkit/integration/build_manifest.py

@@ -9,6 +9,7 @@ from lbkit.log import Logger
 from lbkit.build_conan_parallel import BuildConanParallel
 from concurrent.futures import ThreadPoolExecutor
 from lbkit.errors import LiteBmcException
+from lbkit.codegen.codegen import __version__ as codegen_version
 
 log = Logger("product_build")
 
@@ -35,6 +36,10 @@ class BuildManifest(Task):
         self.common_args = "-r " + self.config.remote
         self.common_args += " -pr:b {} -pr:h {}".format(self.config.profile_build, self.config.profile_host)
         self.common_args += " -o */*:test=False"
+        cv = self.get_manifest_config("metadata/codegen_version")
+        if cv == "latest":
+            cv = codegen_version.str
+        self.common_args += " -o */*:codegen_version=" + cv
 
     def deploy(self, graph_file):
         with open(graph_file, "r") as fp:

{lbkit-0.7.4 → lbkit-0.8.0}/lbkit/misc.py

@@ -55,6 +55,9 @@ class SmartFormatter(argparse.HelpFormatter):
     def _split_lines(self, text, width):
         ret = []
         for line in text.split("\n"):
+            if not line.strip():
+                ret.extend(" ")
+                continue
             ret.extend(super()._split_lines(line, width))
         return ret
 

{lbkit-0.7.4 → lbkit-0.8.0}/lbkit/tools.py

@@ -17,9 +17,10 @@ from lbkit.misc import Color
 
 class Tools(object):
     """基础工具类"""
-    def __init__(self, log_name: str):
-        os.makedirs(misc.LOG_DIR, exist_ok=True)
-        self.log_name = os.path.join(misc.LOG_DIR, f"{log_name}.log")
+    def __init__(self, log_name: str, log_dir: str=".temp"):
+        self.log_dir = os.path.realpath(log_dir)
+        os.makedirs(self.log_dir, exist_ok=True)
+        self.log_name = os.path.join(self.log_dir, f"{log_name}.log")
         self.log: Logger = Logger(log_name)
 
     @staticmethod

{lbkit-0.7.4 → lbkit-0.8.0}/lbkit/utils/version.py

@@ -5,19 +5,16 @@ 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):
+        if not re.match("^([0-9]|([1-9][0-9]*))\\.([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
+        self.minor = int(chunks[1])
+        self.str = str(self.major) + "." + str(self.minor)
 
     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)):
+        if self.major > next.major or (self.major == next.major and self.minor > next.minor):
             return True
         return False
 
@@ -29,13 +26,13 @@ class Version():
 
     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)):
+        if self.major < next.major or (self.major == next.major and self.minor < next.minor):
             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)):
+        if self.major < next.major or (self.major == next.major and self.minor <= next.minor):
             return True
         return False
 

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

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

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

@@ -1,12 +1,14 @@
 import unittest
 import tempfile
 import os
+import json
 import tracemalloc
 
 tracemalloc.start()
 from lbkit.codegen.idf_interface import IdfInterface
 from lbkit import errors
 from lbkit.codegen.codegen import __version__ as codegen_version
+from lbkit.codegen.codegen import history_versions as codegen_history
 from lbkit.utils.version import Version
 
 schema_dir = os.path.realpath(os.path.join(os.getcwd(), "..", "schema"))
@@ -28,7 +30,7 @@ class TestCodeGenClass(unittest.TestCase):
     def mk_interface_with_number_property(self, name, type, max, min, default_val):
         with open(self.tmp_file, mode="w+") as fp:
             fp.write(f"# yaml-language-server: $schema={schema_dir}/idf.v1.json\n")
-            fp.write("version: \"0.1\"\n")
+            fp.write("version: 1\n")
             fp.write("description: 测试接口，用于验证lb_base/lb_core，同时验证自动生成逻辑\n")
             fp.write("alias: Test\n")
             fp.write("properties:\n")
@@ -42,7 +44,7 @@ class TestCodeGenClass(unittest.TestCase):
     def mk_interface_with_string_property(self, name, type, pattern, default_val):
         with open(self.tmp_file, mode="w+") as fp:
             fp.write(f"# yaml-language-server: $schema={schema_dir}/idf.v1.json\n")
-            fp.write("version: \"0.1\"\n")
+            fp.write("version: 1\n")
             fp.write("description: 测试接口，用于验证lb_base/lb_core，同时验证自动生成逻辑\n")
             fp.write("alias: Test\n")
             fp.write("properties:\n")
@@ -56,7 +58,7 @@ class TestCodeGenClass(unittest.TestCase):
     def mk_interface_with_double_property(self, name, type, default_val, max=None, min=None, exclusive_max=None, exclusive_min=None):
         with open(self.tmp_file, mode="w+") as fp:
             fp.write(f"# yaml-language-server: $schema={schema_dir}/idf.v1.json\n")
-            fp.write("version: \"0.1\"\n")
+            fp.write("version: 1\n")
             fp.write("description: 测试接口，用于验证lb_base/lb_core，同时验证自动生成逻辑\n")
             fp.write("alias: Test\n")
             fp.write("properties:\n")
@@ -77,7 +79,7 @@ class TestCodeGenClass(unittest.TestCase):
     def validate_boolean(self, name, type, default):
         with open(self.tmp_file, mode="w+") as fp:
             fp.write(f"# yaml-language-server: $schema={schema_dir}/idf.v1.json\n")
-            fp.write("version: \"0.1\"\n")
+            fp.write("version: 1\n")
             fp.write("description: 测试接口，用于验证lb_base/lb_core，同时验证自动生成逻辑\n")
             fp.write("alias: Test\n")
             fp.write("properties:\n")
@@ -283,46 +285,67 @@ class TestCodeGenClass(unittest.TestCase):
 
 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.3").bt("5.2"))
         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.assertTrue(Version("6.1").bt("5.2"))
+        self.assertTrue(Version("5.3").bt("5.2"))
         self.assertFalse(Version("5.2").bt("5.2"))
+        self.assertFalse(Version("5.1").bt("5.2"))
+        self.assertFalse(Version("4.3").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"))
+        self.assertFalse(Version("4.1").bt("5.2"))
 
     def test_version_be(self):
+        self.assertTrue(Version("6.3").be("5.2"))
+        self.assertTrue(Version("6.2").be("5.2"))
+        self.assertTrue(Version("6.1").be("5.2"))
+        self.assertTrue(Version("5.3").be("5.2"))
         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"))
+        self.assertFalse(Version("5.1").be("5.2"))
+        self.assertFalse(Version("4.3").be("5.2"))
+        self.assertFalse(Version("4.2").be("5.2"))
+        self.assertFalse(Version("4.1").be("5.2"))
 
     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.3").le("5.2"))
         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.assertFalse(Version("6.1").le("5.2"))
+        self.assertFalse(Version("5.3").le("5.2"))
         self.assertTrue(Version("5.2").le("5.2"))
+        self.assertTrue(Version("5.1").le("5.2"))
+        self.assertTrue(Version("4.3").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"))
+        self.assertTrue(Version("4.1").le("5.2"))
 
     def test_version_lt(self):
+        self.assertFalse(Version("6.3").lt("5.2"))
+        self.assertFalse(Version("6.2").lt("5.2"))
+        self.assertFalse(Version("6.1").lt("5.2"))
+        self.assertFalse(Version("5.3").lt("5.2"))
         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"))
-
+        self.assertTrue(Version("4.2").lt("5.2"))
+        self.assertTrue(Version("4.1").lt("5.2"))
+
+    def test_codegen_version_schema(self):
+        """
+        测试pdf模式文件的metadata/codegen_version可选值与codegen.py的history_versions是否保持一致
+        """
+        pdf_file = os.path.join("..", "schema", "pdf.v1.json")
+        pdf_file = os.path.realpath(pdf_file)
+        with open(pdf_file, "r") as fp:
+            data = json.load(fp)
+        data = data.get("properties", {}).get("metadata", {})
+        data = data.get("properties", {}).get("codegen_version", {})
+        data = data.get("enum", [])
+        data.sort()
+        # latest表示最新的版本生成工具版本号
+        versions = ["latest"]
+        for ver, _ in codegen_history.items():
+            versions.append(ver)
+        versions.sort()
+        self.assertTrue(data == versions)
 
 if __name__ == "__main__":
     unittest.main()

lbkit-0.7.4/lbkit/__init__.py

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