lbkit 0.9.4__tar.gz → 0.9.6__tar.gz

{lbkit-0.9.4/lbkit.egg-info → lbkit-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lbkit
-Version: 0.9.4
+Version: 0.9.6
 Summary: Tools provided by litebmc.com
 Home-page: https://www.litebmc.com
 Author: xuhj@litebmc.com
@@ -22,6 +22,7 @@ Requires-Dist: gitpython
 Requires-Dist: inflection
 Requires-Dist: meson>=1.4.0
 Requires-Dist: psutil
+Requires-Dist: loguru
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

lbkit-0.9.6/lbkit/__init__.py

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

{lbkit-0.9.4 → lbkit-0.9.6}/lbkit/build_conan_parallel.py

@@ -8,19 +8,20 @@ from lbkit import misc
 from lbkit.tools import Tools
 from lbkit.misc import Color
 
-tools = Tools("comp_build")
-log = Logger("comp_build")
+tools = Tools()
+log = tools.log
 
 
 class BuildConanParallel(object):
-    def __init__(self, orderinfo, remote):
+    def __init__(self, orderinfo, lockfile, remote):
         self.orderinfo = orderinfo
         self.remote = remote
+        self.lockfile = lockfile
 
     def _build_package(self, logfile, build_args, public_args):
-        cmd = f"conan install {build_args} {public_args}"
+        cmd = f"conan install {build_args} {public_args} --lockfile={self.lockfile} --lockfile-partial"
         log.info("{}build start:    '{}".format(Color.GREEN, Color.RESET_ALL) + cmd + '  log file: ' + logfile)
-        tools.exec(cmd, ignore_error=True, log_name=logfile, echo_cmd=False)
+        tools.exec(cmd, log_name=logfile, echo_cmd=False)
         log.info("{}build finished: '{}".format(Color.GREEN, Color.RESET_ALL) + cmd + '  log file: ' + logfile)
 
     def _build(self):

{lbkit-0.9.4 → lbkit-0.9.6}/lbkit/cli.py

@@ -3,7 +3,6 @@ import inspect
 import os
 import signal
 import sys
-import shutil
 import argparse
 import traceback
 from lbkit import __version__ as client_version
@@ -12,14 +11,13 @@ from lbkit.component.build import BuildComponent
 from lbkit.component.test import TestComponent
 from lbkit.tasks.executor import Executor
 from lbkit.component.arg_parser import ArgParser
-from lbkit.ci_robot.gitee import Gitee
 from lbkit.log import Logger
 from lbkit import misc
 from lbkit import errors
 from lbkit.ukr.build import UKRBuild
 from lbkit.utils.env_detector import EnvDetector
 
-log = Logger("cli")
+log = Logger()
 
 
 class Command(object):
@@ -92,14 +90,6 @@ class Command(object):
             exe = Executor(env)
             exe.run()
 
-    def gitee(self, *args):
-        """
-        Call gitee api.
-
-            CI场景调用gitee的API完成像标签、评论等基本操作
-        """
-        _ = Gitee(sys.argv[2:])
-
     # test package
     def test(self, *args):
         """
@@ -123,7 +113,6 @@ class Command(object):
                 ("Build Component commands", ["new", "build", "test"]),
                 ("Build Product commands", ["build"]),
                 ("Misc commands", ["help"]),
-                ("CI Robot commands", ["gitee"])
                ]
 
         def check_all_commands_listed():
@@ -223,7 +212,6 @@ class Command(object):
             log.error(exc)
             ret_code = 0
         except SystemExit as exc:
-            log.error("lbk exit with exception:")
             if exc.code != 0:
                 log.error("Exiting with code: %d" % exc.code)
             ret_code = exc.code
@@ -233,7 +221,7 @@ class Command(object):
                 print(traceback.format_exc())
             ret_code = -1
             msg = str(exc)
-            log.error(misc.Color.RED + msg + misc.Color.RESET_ALL)
+            log.error(msg)
         except errors.TestException:
             log.error("lbk exit with exception:")
             log.error(exc)
@@ -245,8 +233,6 @@ class Command(object):
 def main(args):
     # 使能revision功能
     os.environ["CONAN_REVISIONS_ENABLED"] = "1"
-    # 创建并清空日志目录
-    shutil.rmtree(misc.LOG_DIR, ignore_errors=True)
     os.makedirs(misc.LOG_DIR, exist_ok=True)
     def ctrl_c_handler(_, __):
         sys.exit(-3)
@@ -259,5 +245,8 @@ def main(args):
 
     command = Command()
     error = command.run(args)
+    if error != 0:
+        log.error("Build failed, You can find all build logs in the directory: " + misc.LOG_DIR)
+    else:
+        log.success("Build successfully, You can find all build logs in the directory: " + misc.LOG_DIR)
     sys.exit(error)
-

{lbkit-0.9.4 → lbkit-0.9.6}/lbkit/codegen/codegen.py

@@ -16,7 +16,7 @@ from lbkit.errors import ArgException
 from lbkit.misc import SmartFormatter
 
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
-log = Logger("codegen")
+log = Logger()
 
 
 class CodeGenHistory():
@@ -102,6 +102,7 @@ def codegen_version_arg(parser: argparse.ArgumentParser, default=__version__.str
 
 class CodeGen(object):
     def __init__(self, args):
+        Logger("codegen.log")
         self.args = args
         self.codegen_version = __version__
         self.log_level = "NOTSET"
@@ -152,11 +153,6 @@ class CodeGen(object):
                                          formatter_class=SmartFormatter)
         codegen_version_arg(parser)
         parser.add_argument("-d", "--directory", help='generate code directory', default=".")
-        parser.add_argument("-l", "--log_level", help='show log level',
-                            choices=[
-                                "CRITICAL", "FATAL", "ERROR", "WARN",
-                                "WARNING", "INFO", "DEBUG", "NOTSET",
-                            ], default=None)
         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)
@@ -164,9 +160,6 @@ class CodeGen(object):
         group1.add_argument("-i", "--idf_file", help='A IDF file to be processed e.g.: com.litebmc.Upgrade.xml', default=None)
 
         args = parser.parse_args(self.args)
-        if args.log_level:
-            self.log_level = args.log_level
-            log.setLevel(self.log_level)
 
         if args.cdf_file:
             if not os.path.isfile(args.cdf_file):
@@ -212,7 +205,7 @@ class CodeGen(object):
         if  not os.path.isfile(intf_file):
             raise ArgException(f"The IDF file ({intf_file}) not exist")
         if not os.path.isdir(out_dir):
-            log.warning(f"Directory {args.directory} not exist, try create")
+            log.warn(f"Directory {args.directory} not exist, try create")
             os.makedirs(out_dir)
         self._gen(intf_file, out_dir, args.codetype)
 

{lbkit-0.9.4 → lbkit-0.9.6}/lbkit/codegen/idf_interface.py

@@ -11,7 +11,7 @@ from lbkit.misc import load_yml_with_json_schema_validate, get_json_schema_file
 from lbkit.errors import OdfValidateException, LiteBmcException
 from lbkit.helper import SigInvalidException, validate_glib_signature
 
-log = Logger("gen_interface")
+log = Logger()
 alias = None
 
 class IDFException(Exception):
@@ -124,6 +124,8 @@ CTYPE_SIGNATURE_MAP = {
 }
 
 def get_intfname_and_ctype(class_alias: str, ctype: str):
+    if ctype == "self":
+        return class_alias, class_alias
     match = re.findall(r"([\w][\w\d]*)", ctype)
     intf = ".".join(match[:-1])
     ctype = match[-1]
@@ -426,6 +428,8 @@ class IdfCtypeRender():
             if is_array:
                 # 结构体数组初始化时为二级空指针，以空指针结束
                 return [f"{stru_name} *<const>*<arg_name>"]
+            elif stru_name == self.intf.alias:
+                return [f"<const>struct _{stru_name} *<arg_name>"]
             else:
                 # 结构体成员初始化时为空结构体，由反序列化时填充内容
                 return [f"<const>{stru_name} *<arg_name>"]
@@ -972,7 +976,7 @@ class IdfStructure(IdfBase):
             if odf is not None:
                 schema[prop.name] = odf
             else:
-                log.warning(f"the schema of prop {prop.name} is None")
+                log.warn(f"the schema of prop {prop.name} is None")
         odf = {
             "type": "object",
             "additionalProperties": False,
@@ -1078,7 +1082,7 @@ class IdfDictionary():
             if odf is not None:
                 schema[prop.name] = odf
             else:
-                log.warning(f"the schema of prop {prop.name} is None")
+                log.warn(f"the schema of prop {prop.name} is None")
         key_schema = self.key_obj.odf_schema(False)
         odf = {
             "type": "array",
@@ -1191,7 +1195,7 @@ class IdfInterface(IdfInterfaceBase):
                 schema[prop.name] = odf
                 with_schema_prop_cnt += 1
             else:
-                log.warning(f"the schema of prop {prop.name} is None")
+                log.warn(f"the schema of prop {prop.name} is None")
             # 顶层属性可以有一个flags标记属性
             schema[f"_{prop.name}_flags"] =  {
                 "enum": ["per_save", "per_power_off", "per_reboot"]
@@ -1312,17 +1316,6 @@ class IdfInterface(IdfInterfaceBase):
             for item in items:
                 obj = IdfPluginAction(self, item)
                 self.plugin.actions.append(obj)
-        log.debug("interface signature: " + self.signature)
-        for signal in self.signals:
-            log.debug(f"{signal.name} signature: " + signal.signature)
-        for method in self.methods:
-            log.debug(f"{method.name} in signature: " + method.in_signature + ", out signature: " + method.out_signature)
-        # for name, stru in self.structures.items():
-        #     log.debug(f"{name} signature: " + stru.signature)
-        # for name, enum in self.enumerations.items():
-        #     log.debug(f"{name} signature: " + enum.signature)
-        # for name, dictionary in self.dictionaries.items():
-        #     log.debug(f"{name} signature: " + dictionary.signature)
         # 接口本身也是一个结构体
         intf_stru = IdfStructure(self, idf, propety_key="properties")
         self.structures[self.alias] = intf_stru

{lbkit-0.9.4 → lbkit-0.9.6}/lbkit/codegen/template/public.c.mako

@@ -971,7 +971,7 @@ static ${class_name}_Properties _${class_name}_properties =
 % if (prop.signature in ["b", "y", "n", "q", "i", "u", "x", "t", "d", "o", "s", "g", "ab", "ay", "an", "aq", "ai", "au", "ax", "at", "ad", "as", "ao", "ag"] and prop.val_validate()):
         .check = ${class_name}_check_${prop.name}_variant,
 % else:
-<% match = re.match(f"^array\[enum\[(.*)\]\]$", prop.ctype) %>\
+<% match = re.match(rf"^array\[enum\[(.*)\]\]$", prop.ctype) %>\
     % if match:
 <% match_enum = re.findall(r"([\w][\w\d]*)", match.group(1)) %>\
             % if match_enum[0] == "self":
@@ -980,7 +980,7 @@ static ${class_name}_Properties _${class_name}_properties =
         .check = ${match_enum[0]}_${match_enum[-1]}_check_enum_variant_v,
             % endif
     % else:
-<% match = re.match(f"^enum\[(.*)\]$", prop.ctype) %>\
+<% match = re.match(rf"^enum\[(.*)\]$", prop.ctype) %>\
         % if match:
 <% match_enum = re.findall(r"([\w][\w\d]*)", match.group(1)) %>\
             % if match_enum[0] == "self":

{lbkit-0.9.4 → lbkit-0.9.6}/lbkit/component/arg_parser.py

@@ -25,6 +25,8 @@ class ArgParser():
                             help="Upload package to remote")
         parser.add_argument("-s", "--from_source", action="store_true",
                             help="Build all depencencies component from source")
+        parser.add_argument("-ts", "--tar_source", action="store_true",
+                            help="Use the tar command to compress the source code package.")
         parser.add_argument("--summary", action="store_true",
                             help=argparse.SUPPRESS)
         parser.add_argument("--cov", action="store_true",

{lbkit-0.9.4 → lbkit-0.9.6}/lbkit/component/build.py

@@ -1,10 +1,9 @@
 """组件构建"""
 import os
 import yaml
-import shutil
+import shlex
 import re
 import json
-import sys
 from multiprocessing import Pool
 import traceback
 from argparse import ArgumentParser
@@ -12,14 +11,15 @@ from jsonschema import validate, ValidationError
 from git import Repo
 from git.exc import InvalidGitRepositoryError
 from mako.lookup import TemplateLookup
-from lbkit.misc import Color, load_yml_with_json_schema_validate, get_json_schema_file, load_json_schema
+from lbkit.misc import load_yml_with_json_schema_validate, get_json_schema_file, load_json_schema
 from lbkit import errors
 from lbkit.codegen.codegen import CodeGen, history_versions
 from lbkit.tools import Tools
+from lbkit.log import Logger
 from lbkit.build_conan_parallel import BuildConanParallel
 from lbkit.codegen.codegen import Version
 
-tools = Tools("comp_build")
+tools = Tools()
 log = tools.log
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
 
@@ -53,6 +53,7 @@ class DeployComponent():
 class BuildComponent():
     def __init__(self, args_parser: ArgumentParser, args=None):
         self.cwd = os.getcwd()
+        Logger("build_comp.log")
         self.deploy_success = True
         self.options = args_parser.parse_args(args)
         self.options.build_type = self.options.build_type.capitalize()
@@ -66,8 +67,16 @@ class BuildComponent():
         self.from_source = self.options.from_source
         # 当前组件及其依赖将被部署到rootfs目录
         self.rootfs_dir = os.path.join(self.cwd, ".temp", "rootfs")
-        shutil.rmtree(self.rootfs_dir, ignore_errors=True)
-        os.makedirs(self.rootfs_dir, exist_ok=True)
+        tools.makedirs(self.rootfs_dir, True, True)
+        self.conan_index = os.path.join(self.cwd, ".temp", "conan-index")
+        tools.makedirs(self.conan_index, True, True)
+        self.enable_tar_source = self.options.tar_source
+        self.source_file = os.path.join(self.cwd, ".temp", "source.tar.gz")
+        self.graphfile = os.path.join(self.cwd, ".temp", "graph.info")
+        self.lockfile = os.path.join(self.cwd, ".temp", "conan.lock")
+        self.orderfile = os.path.join(self.cwd, ".temp", "graph.order")
+        # 当组件构建完成后可以获取到包id, 初始化时置空
+        self.package_id = None
 
         self.pkg = None
         self.base_cmd = ""
@@ -88,8 +97,23 @@ class BuildComponent():
         for pkg_option in self.options.pkg_options:
             self.base_cmd += " -o " + pkg_option
         self.base_cmd += f" -o */*:codegen_version={self.options.codegen_version}"
-        if self.name == "lb_base":
-            self.base_cmd += f" -o */*:compatible_required={self.codegen_version.info.lb_base_compatible_required}"
+        self.base_cmd += f" -o */*:compatible_required={self.codegen_version.info.lb_base_compatible_required}"
+
+    @staticmethod
+    def _check_conanfile_if_tracked():
+        """检查conanfile.py是否被git跟踪"""
+        tracked = False
+        try:
+            repo = Repo(".")
+            for entry in repo.commit().tree.traverse():
+                if entry.path == "conanfile.py":
+                    tracked = True
+                    break
+        except InvalidGitRepositoryError:
+            log.debug("Invalid git repository")
+            return
+        if tracked:
+            raise Exception("conanfile.py is being tracked by git. You can untrack it by executing the command `git rm --f conanfile.py`")
 
     def get_package_version(self):
         """
@@ -105,17 +129,40 @@ class BuildComponent():
             print(str(e))
             return None
 
-    @property
-    def _is_conanfile_tracked(self):
-        """检查conanfile.py是否被git跟踪"""
+    def tar_source(self, tar_path):
+        """
+        将self.cwd目录下未被git跟踪的文件使用tar命令压缩到tar_path
+
+        :param tar_path: tar压缩包路径
+        """
+        untracked_files = [".temp"]
+        if os.path.exists("test_package/test_interface"):
+            untracked_files.append("test_package/test_interface")
+        if os.path.exists("conanfile.py"):
+            untracked_files.append("conanfile.py")
+        if os.path.exists("__pycache__"):
+            untracked_files.append("__pycache__")
+        if os.path.exists(".git"):
+            untracked_files.append(".git")
+        if os.path.exists(".gitignore"):
+            untracked_files.append(".gitignore")
+
         try:
-            repo = Repo(".")
-            for entry in repo.commit().tree.traverse():
-                if entry.path == "conanfile.py":
-                    return True
-        except InvalidGitRepositoryError as e:
-            log.error("Invalid git repository, conanfile.py will be generated by lbkit")
-        return False
+            repo = Repo(self.cwd)
+            # 获取未被跟踪的文件
+            untracked_files.extend(repo.untracked_files)
+        except InvalidGitRepositoryError:
+            raise errors.LiteBmcException(f"{self.cwd} is not a valid git repository")
+
+        # 构建tar命令，使用-C指定工作目录
+        cmd_parts = ["tar", "--format=gnu", "-czf", tar_path, f"--transform=s|^.|{self.version}|", "-C", self.cwd]
+        for file in untracked_files:
+            cmd_parts.append("--exclude=" + file)
+        cmd_parts.append(".")
+        cmd = " ".join(shlex.quote(part) for part in cmd_parts)
+
+        tools.exec(cmd, verbose=True)
+        log.info(f"Archived {len(untracked_files)} untracked files to {tar_path}")
 
     def gen_conaninfo(self):
         package_yml = os.path.join(self.cwd, "metadata/package.yml")
@@ -131,10 +178,15 @@ class BuildComponent():
         # 构建命令未指定channel时从package.yml中读取
         pkg["channel"] = self.channel
         pkg["version"] = self.get_package_version()
-        self.pkg = pkg
         # 从package.yml加载基础信息
         self.name = pkg.get("name")
         self.version = pkg.get("version")
+        self.tar_source(self.source_file)
+        pkg["source_url"] = self.source_file
+        pkg["sha256"] = tools.file_digest_sha256(self.source_file)
+        pkg["enable_tar_source"] = self.enable_tar_source
+        pkg["source_dir"] = self.cwd
+        self.pkg = pkg
 
         self.package = self.name + "/" + self.version
         if self.user != "litebmc" or self.channel != "release":
@@ -155,17 +207,14 @@ class BuildComponent():
             for k, v in option.items():
                 self.base_cmd += f" -o {conan}/*:{k}={v}"
 
-        # 生成conan构建脚本
-        conanfile = os.path.join(self.cwd, "conanbase.py")
-        # 当git未跟踪conanfile.py时生成新的conanfile.py
-        if not self._is_conanfile_tracked:
-            conanfile = os.path.join(self.cwd, "conanfile.py")
+        # 检查git是是否跟踪conanfile.py
+        self._check_conanfile_if_tracked()
+        conanfile = os.path.join(self.conan_index, "conanfile.py")
 
         # 使用litebmc.conanfile.mako模板生成基础litebmc公共conanfile
         lookup = TemplateLookup(directories=os.path.join(lb_cwd, "template"))
         template = lookup.get_template("conanbase.mako")
         conandata = template.render(lookup=lookup, pkg=pkg,
-                                    conanfile_tracked=self._is_conanfile_tracked,
                                     codegen_version=self.codegen_version,
                                     codegen_history=history_versions)
         # 写入文件
@@ -196,6 +245,8 @@ class BuildComponent():
             context = info.get("context")
             if context != "host":
                 continue
+            if ref.startswith(self.package):
+                self.package_id = id
             dep = DeployComponent(ref, id, self.rootfs_dir)
             pool.apply_async(dep.run, error_callback=self._copy_failed)
         pool.close()
@@ -203,32 +254,29 @@ class BuildComponent():
 
     def build(self):
         log.info(os.getcwd())
-
+        os.chdir(self.conan_index)
         export_cmd = "conan export . "
         if self.user != "litebmc" or self.channel != "release":
             export_cmd += f"--user={self.user} --channel={self.channel}"
-        tools.run(export_cmd, capture_output=False, stdout=sys.stdout, stderr=sys.stdout)
+        tools.exec(export_cmd, verbose=True)
 
-        lockfile = os.path.join(self.cwd, ".temp", "conan.lock")
-        orderfile = os.path.join(self.cwd, ".temp", "graph.order")
-        graph_cmd = f"conan graph build-order . {self.base_cmd} --order-by=recipe -f json --out-file={orderfile}"
+        graph_cmd = f"conan graph build-order . {self.base_cmd} --order-by=recipe -f json --out-file={self.orderfile}"
         if self.from_source:
             graph_cmd += " --build='*'"
         else:
             graph_cmd += " --build=missing"
-        graph_cmd += f" --lockfile-out={lockfile}"
-        tools.run(graph_cmd)
-        bcp = BuildConanParallel(orderfile, self.options.remote)
+        graph_cmd += f" --lockfile-out={self.lockfile}"
+        tools.exec(graph_cmd, verbose=True)
+        bcp = BuildConanParallel(self.orderfile, self.lockfile, self.options.remote)
         bcp.build()
         cmd = f"conan create {self.base_cmd} --build='{self.name}/*'"
-        tools.run(cmd, capture_output=False)
+        tools.exec(cmd, verbose=True)
 
-        graphfile = os.path.join(self.cwd, ".temp", "graph.info")
-        graph_cmd = f"conan graph info . {self.base_cmd} -f json --lockfile={lockfile}"
-        tools.pipe([graph_cmd], out_file=graphfile)
+        graph_cmd = f"conan graph info . {self.base_cmd} -f json --lockfile={self.lockfile}"
+        tools.pipe([graph_cmd], out_file=self.graphfile)
 
         log.success(f"start deploy {self.package} and is's dependency packages")
-        self.deploy(graphfile)
+        self.deploy(self.graphfile)
 
         if not self.deploy_success:
             raise Exception("Deploy component failed")
@@ -301,10 +349,19 @@ class BuildComponent():
         if not ok:
             raise errors.OdfValidateException("Validate odf files with error, build failed")
 
+    def conan_test(self):
+        # 仅测试远程仓登录状态，如果需要登录的，需要输入账号密码
+        log.info("Test the login status of the Conan remote repository")
+        log.info("If glib/2.81.0 not found, you must add litebmc repository using the command: conan remote add litebmc  https://litebmc.com/conan/release")
+        cmd = "conan search glib/2.81.0"
+        if self.options.remote:
+            cmd += f' -r {self.options.remote}'
+        tools.run(cmd, capture_output=False)
 
     def run(self):
         cmd = f"conan remove {self.package} -c"
         tools.exec(cmd)
+        self.conan_test()
         gen = CodeGen(["-c", "./metadata/package.yml"])
         gen.run()
         # 部署依赖
@@ -315,15 +372,6 @@ class BuildComponent():
             self.upload()
         log.success(f"build {self.package} successfully")
 
-    @property
-    def package_id(self):
-        cmd = f"conan graph info . {self.base_cmd} --filter=package_id"
-        res = tools.run(cmd, capture_output=True)
-        match = re.search(r"package_id: ([a-f0-9]{40})", res.stdout)
-        if match is None:
-            raise errors.LiteBmcException(f"Get package if of {self.package} failed")
-        return match.group(1)
-
     @staticmethod
     def package_folder(self):
         cmd = f"conan cache path {self.package}#latest:{self.package_id}"
@@ -340,7 +388,6 @@ class BuildComponent():
         try:
             self.run()
         except Exception as e:
-            log.error(
-                f"build {self.package} {Color.RED}failed{Color.RESET_ALL}")
+            log.error(f"build {self.package} failed")
             log.info(e)
             os._exit(-2)

{lbkit-0.9.4 → lbkit-0.9.6}/lbkit/component/template/conanbase.mako

@@ -69,15 +69,30 @@ class LiteBmcConan(ConanFile):
 % endif
     }
 
+% if pkg["enable_tar_source"]:
     def export(self):
-% if conanfile_tracked:
-        # files.copy(self, "conanbase.py", self.recipe_folder, self.export_folder)
-        files.copy(self, "conanbase.py")
-% endif
-        git = Git(self, self.recipe_folder)
+        files.update_conandata(self, {
+            "sources": {
+                "${pkg["version"]}": {
+                    "url": "${pkg["source_url"]}",
+                    "sha256": "${pkg["sha256"]}"
+                }
+            }
+        })
+
+    def source(self):
+        source = self.conan_data["sources"][self.version]
+        url = source.get("url")
+        if (not url.startswith("http")) and os.path.isfile(url):
+            files.unzip(self, url, destination=".", strip_root=True)
+        else:
+            files.get(self, **source, strip_root=True)
+% else:
+    def export(self):
+        git = Git(self, "${pkg["source_dir"]}")
         if git.is_dirty():
             print(f"{Fore.YELLOW}Waring: Local repo is dirty.{Style.RESET_ALL}")
-            files.update_conandata(self, {"sources": {"commit": None, "url": None, "pwd": os.getcwd()}})
+            files.update_conandata(self, {"sources": {"commit": None, "url": None, "pwd": "${pkg["source_dir"]}"}})
             return
 
         scm_url = None
@@ -89,7 +104,7 @@ class LiteBmcConan(ConanFile):
                 scm_url = git.get_remote_url(remote)
                 break
         if not scm_url:
-            files.update_conandata(self, {"sources": {"commit": None, "url": None, "pwd": os.getcwd()}})
+            files.update_conandata(self, {"sources": {"commit": None, "url": None, "pwd": "${pkg["source_dir"]}"}})
             return
         files.update_conandata(self, {"sources": {"commit": scm_commit, "url": scm_url}})
 
@@ -101,6 +116,7 @@ class LiteBmcConan(ConanFile):
             git.checkout(commit=sources["commit"])
         else:
             files.copy(self, "*", src=sources["pwd"], dst=".")
+% endif
 
     def requirements(self):
 % if len(pkg.get("requires", {})) > 0: