lbkit 0.9.3__tar.gz → 0.9.5__tar.gz

{lbkit-0.9.3 → lbkit-0.9.5}/AUTHORS

@@ -1,4 +1,4 @@
-Below are just a few of the people who have contributed to litebmc/toolkit.
+Below are just a few of the people who have contributed to litebmc/lbkit.
 
 ----------
 xuhaijun        <xuhj@litebmc.com>

{lbkit-0.9.3/lbkit.egg-info → lbkit-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lbkit
-Version: 0.9.3
+Version: 0.9.5
 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.5/lbkit/__init__.py

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

lbkit-0.9.5/lbkit/build_conan_parallel.py

@@ -0,0 +1,62 @@
+"""任务基础类"""
+import os
+import json
+import tempfile
+from lbkit.log import Logger
+from concurrent.futures import ThreadPoolExecutor, Future, as_completed
+from lbkit import misc
+from lbkit.tools import Tools
+from lbkit.misc import Color
+
+tools = Tools()
+log = tools.log
+
+
+class BuildConanParallel(object):
+    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} --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)
+        log.info("{}build finished: '{}".format(Color.GREEN, Color.RESET_ALL) + cmd + '  log file: ' + logfile)
+
+    def _build(self):
+        with open(self.orderinfo, "r") as fp:
+            order_info = json.load(fp)
+        public_args = order_info.get("profiles", {}).get("self", {}).get("args", "")
+        for orders in order_info.get("order", []):
+            threadPool = ThreadPoolExecutor(max_workers=(os.cpu_count() + 1) // 2)
+            results: list[Future] = []
+            for order in orders:
+                ref = order.get("ref")
+                pkgname = ref.split("/")[0]
+                logfile = f"{misc.LOG_DIR}/conan_{pkgname}.log"
+                packages = order.get("packages", [])
+                for package in packages:
+                    for pkg in package:
+                        binary = pkg.get("binary", "")
+                        if binary == 'Download':
+                            pkgid = pkg.get("package_id")
+                            cmd = f'conan download {ref}:{pkgid}'
+                            if self.remote:
+                                cmd += f' -r {self.remote}'
+                            tools.exec(cmd)
+                            continue
+                        if binary != "Build":
+                            continue
+                        build_args = pkg.get("build_args", "")
+                        result = threadPool.submit(self._build_package, logfile, build_args, public_args)
+                        results.append(result)
+            for result in as_completed(results):
+                result.result()
+
+    def build(self):
+        cwd = os.getcwd()
+        tmp = tempfile.TemporaryDirectory()
+        os.chdir(tmp.name)
+        self._build()
+        os.chdir(cwd)

{lbkit-0.9.3 → lbkit-0.9.5}/lbkit/ci_robot/gitee.py

@@ -8,9 +8,10 @@ import re
 from argparse import ArgumentParser
 from lbkit import errors
 from lbkit.tools import Tools
+from lbkit.log import Logger
 from argparse import RawTextHelpFormatter
 
-tools = Tools("comp_build")
+tools = Tools()
 log = tools.log
 cwd = os.getcwd()
 lb_cwd = os.path.split(os.path.realpath(__file__))[0]
@@ -35,6 +36,7 @@ class GiteeCommandInfo(object):
 
 class Gitee():
     def __init__(self, args=None):
+        Logger("gitee.log")
         parser = argparse.ArgumentParser(
             description="Build component", formatter_class=RawTextHelpFormatter)
         sub_parser = parser.add_subparsers(help="sub-commands help")

{lbkit-0.9.3 → lbkit-0.9.5}/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
@@ -19,7 +18,7 @@ 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):
@@ -223,7 +222,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 +231,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 +243,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 +255,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.3 → lbkit-0.9.5}/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.3 → lbkit-0.9.5}/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):
@@ -972,7 +972,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 +1078,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 +1191,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 +1312,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.3 → lbkit-0.9.5}/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.3 → lbkit-0.9.5}/lbkit/component/build.py

@@ -1,7 +1,7 @@
 """组件构建"""
 import os
 import yaml
-import shutil
+import shlex
 import re
 import json
 from multiprocessing import Pool
@@ -11,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]
 
@@ -52,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()
@@ -65,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 = ""
@@ -90,6 +100,22 @@ class BuildComponent():
         if self.name == "lb_base":
             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):
         """
         从CMakeLists.txt读取版本号，格式需要满足正则表达式：project\((.*)VERSION ([0-9][1-9]*.[0-9][1-9]*.[0-9][1-9]*)\)
@@ -104,17 +130,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")
@@ -130,10 +179,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":
@@ -154,17 +208,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)
         # 写入文件
@@ -195,6 +246,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()
@@ -202,30 +255,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)
-        # import sys
-        # sys.exit(-1)
-
-        lockfile = os.path.join(self.cwd, ".temp", "conan.lock")
-        graphfile = os.path.join(self.cwd, ".temp", "graph.info")
-        lock_cmd = f"conan lock create . {self.base_cmd} --lockfile-out={lockfile}"
-        tools.run(lock_cmd, capture_output=False)
-        graph_cmd = f"conan graph info . {self.base_cmd} -f json --lockfile={lockfile}"
-        tools.pipe([graph_cmd], out_file=graphfile)
-        log.success(f"start build dependency packages of {self.package}")
-        bcp = BuildConanParallel(graphfile, lockfile, self.base_cmd, self.from_source)
+        tools.exec(export_cmd, verbose=True)
+
+        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={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.exec(cmd, verbose=True)
 
-        cmd = f"conan create . {self.base_cmd} --build=missing"
-        log.info(f"start build {self.package}: {cmd}")
-        tools.run(cmd, capture_output=False)
+        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")
@@ -298,10 +350,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()
         # 部署依赖
@@ -312,32 +373,22 @@ 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)
-        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}"
-        res = tools.run(cmd)
+        res = tools.run(cmd, capture_output=True)
         return res.stdout.strip()
 
     @property
     def build_folder(self):
         cmd = f"conan cache path {self.package}#latest:{self.package_id} --folder=build"
-        res = tools.run(cmd)
+        res = tools.run(cmd, capture_output=True)
         return res.stdout.strip()
 
     def test(self):
         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.3 → lbkit-0.9.5}/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: