xt-cli 0.2.1__py3-none-any.whl

context.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from config import ConfigStore
+from errors import ConfigError, ProjectError
+from models import BuildContext, ConfigSource, ResolvedValue
+from paths import build_global_config_path, normalize_path, resolve_platform_name, resolve_target_path
+from project import has_xmake_project, has_xt_main_target
+
+_DEFAULT_TARGET = "windows/simulator"
+_LOCAL_CONFIG_FILENAME = "xt_conf.jsonc"
+_SDK_MARKER_RELATIVE_PATH = Path(".xt-sdk-version")
+
+
+def build_context(
+    project_dir: str | Path,
+    sdk_dir: str | Path,
+    target: str,
+    *,
+    board: str = "",
+    toolchain_path: str | Path | None = None,
+    debug_enabled: bool = False,
+    resolved_values: dict[str, ResolvedValue] | None = None,
+) -> BuildContext:
+    """构造基础构建上下文。"""
+    normalized_project_dir = normalize_path(project_dir)
+    normalized_sdk_dir = normalize_path(sdk_dir)
+    _validate_project_dir(normalized_project_dir)
+    _validate_sdk_dir(normalized_sdk_dir)
+    normalized_toolchain_path = normalize_path(toolchain_path) if toolchain_path is not None else None
+    resolved_target_path = resolve_target_path(
+        target=target,
+        project_dir=normalized_project_dir,
+        sdk_dir=normalized_sdk_dir,
+    )
+
+    return BuildContext(
+        project_dir=normalized_project_dir,
+        sdk_dir=normalized_sdk_dir,
+        target=target,
+        target_path=resolved_target_path,
+        platform_name=resolve_platform_name(target),
+        board=board,
+        toolchain_path=normalized_toolchain_path,
+        debug_enabled=debug_enabled,
+        resolved_values=resolved_values or {},
+    )
+
+
+def build_context_from_options(
+    *,
+    cwd: str | Path | None = None,
+    project_dir: str | Path | None = None,
+    sdk_dir: str | Path | None = None,
+    target: str | None = None,
+    board: str | None = None,
+    toolchain_path: str | Path | None = None,
+    home: str | Path | None = None,
+) -> BuildContext:
+    """按最小优先级规则构造命令运行上下文。"""
+    resolved_cwd = normalize_path(cwd) if cwd is not None else Path.cwd()
+    resolved_project_dir = normalize_path(project_dir) if project_dir is not None else resolved_cwd
+
+    local_config = _load_config_if_exists(resolved_project_dir / _LOCAL_CONFIG_FILENAME)
+    global_config = _load_config_if_exists(build_global_config_path(home))
+    global_base_dir = normalize_path(home) if home is not None else Path.home()
+
+    resolved_sdk = _resolve_value(
+        sdk_dir,
+        local_config,
+        global_config,
+        "sdk",
+        local_base_dir=resolved_project_dir,
+        global_base_dir=global_base_dir,
+        normalize_as_path=True,
+    )
+    resolved_target = _resolve_value(target, local_config, global_config, "target", default=_DEFAULT_TARGET)
+    resolved_debug = _resolve_value(
+        None,
+        local_config,
+        global_config,
+        "debug",
+        default=0,
+        allow_int=True,
+    )
+    resolved_platform = resolve_platform_name(resolved_target.value)
+    resolved_toolchain = _resolve_toolchain_path(
+        cli_value=toolchain_path,
+        local_config=local_config,
+        global_config=global_config,
+        platform_name=resolved_platform,
+        local_base_dir=resolved_project_dir,
+        global_base_dir=global_base_dir,
+    )
+    resolved_board = _resolve_value(board, local_config, global_config, "board", default="")
+
+    return build_context(
+        project_dir=resolved_project_dir,
+        sdk_dir=resolved_sdk.value,
+        target=resolved_target.value,
+        board=str(resolved_board.value),
+        toolchain_path=resolved_toolchain.value,
+        debug_enabled=bool(resolved_debug.value),
+        resolved_values={
+            "sdk": resolved_sdk,
+            "target": resolved_target,
+            "board": resolved_board,
+            "toolchain_path": resolved_toolchain,
+            "debug": resolved_debug,
+            "project": ResolvedValue(
+                value=resolved_project_dir,
+                source=ConfigSource.CLI if project_dir is not None else ConfigSource.DERIVED,
+            ),
+            "target_path": ResolvedValue(
+                value=resolve_target_path(
+                    target=resolved_target.value,
+                    project_dir=resolved_project_dir,
+                    sdk_dir=normalize_path(resolved_sdk.value),
+                ),
+                source=ConfigSource.DERIVED,
+            ),
+        },
+    )
+
+
+def _load_config_if_exists(path: Path) -> dict[str, Any]:
+    """存在时加载配置文件。"""
+    if not path.is_file():
+        return {}
+    return ConfigStore(path).load()
+
+
+def _normalize_config_path_value(value: str | Path, base_dir: Path | None) -> str:
+    """将配置中的路径值规范化。"""
+    normalized_value = normalize_path(value)
+    if base_dir is not None and not normalized_value.is_absolute():
+        return os.fspath((base_dir / normalized_value).resolve())
+    return os.fspath(normalized_value)
+
+
+def _resolve_value(
+    cli_value: str | Path | None,
+    local_config: dict[str, Any],
+    global_config: dict[str, Any],
+    key: str,
+    *,
+    default: str | int | None = None,
+    local_base_dir: Path | None = None,
+    global_base_dir: Path | None = None,
+    normalize_as_path: bool = False,
+    allow_int: bool = False,
+) -> ResolvedValue:
+    """按优先级解析配置值。"""
+    if cli_value is not None:
+        value = _normalize_config_path_value(cli_value, None) if normalize_as_path else os.fspath(cli_value)
+        return ResolvedValue(value=value, source=ConfigSource.CLI)
+
+    local_value = local_config.get(key)
+    if isinstance(local_value, (str, Path)):
+        value = _normalize_config_path_value(local_value, local_base_dir) if normalize_as_path else os.fspath(local_value)
+        return ResolvedValue(value=value, source=ConfigSource.LOCAL, source_path=str(local_base_dir / _LOCAL_CONFIG_FILENAME) if local_base_dir is not None else None)
+    if allow_int and isinstance(local_value, int):
+        return ResolvedValue(value=local_value, source=ConfigSource.LOCAL, source_path=str(local_base_dir / _LOCAL_CONFIG_FILENAME) if local_base_dir is not None else None)
+
+    global_value = global_config.get(key)
+    if isinstance(global_value, (str, Path)):
+        value = _normalize_config_path_value(global_value, global_base_dir) if normalize_as_path else os.fspath(global_value)
+        return ResolvedValue(value=value, source=ConfigSource.GLOBAL, source_path=str(build_global_config_path(global_base_dir)))
+    if allow_int and isinstance(global_value, int):
+        return ResolvedValue(value=global_value, source=ConfigSource.GLOBAL, source_path=str(build_global_config_path(global_base_dir)))
+
+    if default is not None:
+        return ResolvedValue(value=default, source=ConfigSource.DEFAULT)
+
+    raise ConfigError(f"Missing required context value: {key}")
+
+
+def _resolve_toolchain_path(
+    *,
+    cli_value: str | Path | None,
+    local_config: dict[str, Any],
+    global_config: dict[str, Any],
+    platform_name: str,
+    local_base_dir: Path,
+    global_base_dir: Path,
+) -> ResolvedValue:
+    """按优先级解析 toolchain 路径。"""
+    if cli_value is not None:
+        return ResolvedValue(value=_normalize_config_path_value(cli_value, None), source=ConfigSource.CLI)
+
+    local_toolchains = local_config.get("toolchains")
+    if isinstance(local_toolchains, dict):
+        local_value = local_toolchains.get(platform_name)
+        if isinstance(local_value, (str, Path)):
+            return ResolvedValue(
+                value=_normalize_config_path_value(local_value, local_base_dir),
+                source=ConfigSource.LOCAL,
+                source_path=str(local_base_dir / _LOCAL_CONFIG_FILENAME),
+            )
+
+    global_toolchains = global_config.get("toolchains")
+    if isinstance(global_toolchains, dict):
+        global_value = global_toolchains.get(platform_name)
+        if isinstance(global_value, (str, Path)):
+            return ResolvedValue(
+                value=_normalize_config_path_value(global_value, global_base_dir),
+                source=ConfigSource.GLOBAL,
+                source_path=str(build_global_config_path(global_base_dir)),
+            )
+
+    return ResolvedValue(value=None, source=ConfigSource.DEFAULT)
+
+
+def _validate_project_dir(project_dir: Path) -> None:
+    """校验工程目录结构。"""
+    if not has_xmake_project(project_dir):
+        raise ProjectError(
+            f"Project directory does not contain xmake.lua: {project_dir}"
+        )
+    if not has_xt_main_target(project_dir):
+        raise ProjectError(
+            "Project xmake.lua does not contain 'xt_main': "
+            f"{project_dir / 'xmake.lua'}"
+        )
+
+
+
+def _validate_sdk_dir(sdk_dir: Path) -> None:
+    """校验 sdk 目录结构。"""
+    sdk_marker = sdk_dir / _SDK_MARKER_RELATIVE_PATH
+    if sdk_marker.is_file():
+        return
+    raise ConfigError(
+        f"Invalid sdk directory: {sdk_dir}. Missing required file: .xt-sdk-version"
+    )