mcpywrap-core 0.6.0__py3-none-any.whl

mcpywrap_core/builders/MapPack.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+
+import os
+import shutil
+import click
+import json
+
+
+class MapPack(object):
+
+    pkg_name: str
+    path: str
+    
+    behavior_packs_dir: str
+    resource_packs_dir: str
+
+    behavior_packs = []
+    resource_packs = []
+
+    def __init__(self, pkg_name: str, path: str):
+        self.pkg_name = pkg_name
+        self.path = path
+        self.behavior_packs = []
+        self.resource_packs = []
+
+        # 读取配置文件
+        self.behavior_packs_dir = os.path.join(self.path, "behavior_packs")
+        self.resource_packs_dir = os.path.join(self.path, "resource_packs")
+
+
+        # 遍历行为包目录
+        for pack in sorted(os.listdir(self.behavior_packs_dir)) if os.path.isdir(self.behavior_packs_dir) else []:
+            pack_path = os.path.join(self.behavior_packs_dir, pack)
+            if os.path.isdir(pack_path):
+                self.behavior_packs.append(pack_path)
+        
+
+        # 遍历资源包目录
+        for pack in sorted(os.listdir(self.resource_packs_dir)) if os.path.isdir(self.resource_packs_dir) else []:
+            pack_path = os.path.join(self.resource_packs_dir, pack)
+            if os.path.isdir(pack_path):
+                self.resource_packs.append(pack_path)
+
+    def copy_level_data_to(self, target_dir: str):
+        """
+        复制地图数据到目标目录
+        """
+        # level.dat
+        level_dat_path = os.path.join(target_dir, "level.dat")
+        if not os.path.exists(level_dat_path):
+            origin_level_dat_path = os.path.join(self.path, "level.dat")
+            if os.path.exists(origin_level_dat_path):
+                shutil.copy2(origin_level_dat_path, level_dat_path)
+        # levelname.txt
+        levelname_txt_path = os.path.join(target_dir, "levelname.txt")
+        if not os.path.exists(levelname_txt_path):
+            origin_levelname_txt_path = os.path.join(self.path, "levelname.txt")
+            if os.path.exists(origin_levelname_txt_path):
+                shutil.copy2(origin_levelname_txt_path, levelname_txt_path)
+        # db
+        level_db_dir = os.path.join(target_dir, "db")
+        if not os.path.exists(level_db_dir) and os.path.exists(os.path.join(self.path, "db")):
+            shutil.copytree(os.path.join(self.path, "db"), level_db_dir)
+
+    def copy_resource_packs_to(self, target_map_dir: str):
+        """
+        复制资源包到目标目录
+        """
+        for pack in self.resource_packs:
+            pack_name = os.path.basename(pack)
+            target_pack_dir = os.path.join(target_map_dir, "resource_packs", pack_name)
+            # 先删除目标目录下的包
+            if os.path.exists(target_pack_dir):
+                shutil.rmtree(target_pack_dir)
+            shutil.copytree(pack, target_pack_dir)
+    
+    def copy_behavior_packs_to(self, target_map_dir: str):
+        """
+        复制行为包到目标目录
+        """
+        for pack in self.behavior_packs:
+            pack_name = os.path.basename(pack)
+            target_pack_dir = os.path.join(target_map_dir, "behavior_packs", pack_name)
+            # 先删除目标目录下的包
+            if os.path.exists(target_pack_dir):
+                shutil.rmtree(target_pack_dir)
+            shutil.copytree(pack, target_pack_dir)
+
+    
+    def setup_packs_symlinks_to(self, level_id: str, target_dir: str):
+        """
+        设置行为包和资源包的符号链接到目标目录（本体到远程）
+        """
+        from ..mcstudio.symlinks import setup_map_packs_symlinks
+        setup_map_packs_symlinks(self.path, level_id, target_dir)
+
+    def setup_world_packs_config(self):
+        """根据当前path，生成世界需加载的pack的配置文件"""
+        behavior_packs_config = []
+        if os.path.exists(self.behavior_packs_dir):
+            behavior_packs_config = _find_and_extract_pack_info(self.behavior_packs_dir)
+            if behavior_packs_config:
+                world_behavior_packs_path = os.path.join(self.path, "world_behavior_packs.json")
+                with open(world_behavior_packs_path, 'w', encoding='utf-8') as f:
+                    json.dump(behavior_packs_config, f, ensure_ascii=False, indent=4)
+        
+        resource_packs_config = []
+        if os.path.exists(self.resource_packs_dir):
+            resource_packs_config = _find_and_extract_pack_info(self.resource_packs_dir)
+            if resource_packs_config:
+                world_resource_packs_path = os.path.join(self.path, "world_resource_packs.json")
+                with open(world_resource_packs_path, 'w', encoding='utf-8') as f:
+                    json.dump(resource_packs_config, f, ensure_ascii=False, indent=4)
+        
+        return behavior_packs_config, resource_packs_config
+
+def _find_and_extract_pack_info(packs_dir):
+    """
+    搜索指定目录中的所有包，并从manifest.json中提取信息
+    
+    Args:
+        packs_dir: 包目录路径
+        
+    Returns:
+        list: 包配置列表
+    """
+    packs_config = []
+    
+    # 遍历目录下的所有子目录
+    for pack_name in os.listdir(packs_dir):
+        pack_path = os.path.join(packs_dir, pack_name)
+        
+        # 只处理目录
+        if not os.path.isdir(pack_path):
+            continue
+        
+        # 查找manifest.json或pack_manifest.json
+        manifest_path = os.path.join(pack_path, "manifest.json")
+        if not os.path.exists(manifest_path):
+            manifest_path = os.path.join(pack_path, "pack_manifest.json")
+            if not os.path.exists(manifest_path):
+                continue
+        
+        try:
+            with open(manifest_path, 'r', encoding='utf-8') as f:
+                manifest = json.load(f)
+            
+            # 提取UUID和版本信息
+            if 'header' in manifest:
+                pack_id = manifest['header'].get('uuid')
+                version = manifest['header'].get('version', [0, 0, 1])
+                
+                # 确保版本是列表格式
+                if isinstance(version, list):
+                    version_array = version
+                elif isinstance(version, dict) and 'major' in version and 'minor' in version and 'patch' in version:
+                    version_array = [version['major'], version['minor'], version['patch']]
+                else:
+                    version_array = [0, 0, 1]  # 默认版本
+                
+                if pack_id:
+                    pack_config = {
+                        "pack_id": pack_id,
+                        "type": "Addon",
+                        "version": version_array
+                    }
+                    packs_config.append(pack_config)
+        except Exception as e:
+            click.echo(f"⚠️ 读取包配置失败: {pack_name} - {str(e)}", style="yellow")
+    
+    return packs_config

mcpywrap_core/builders/__init__.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+"""
+构建模块包，提供项目构建、文件处理和监控功能
+"""
+
+from .project_builder import AddonProjectBuilder
+from .dependency_manager import DependencyManager
+
+__all__ = ['AddonProjectBuilder', 'ProjectWatcher', 'FileWatcher', 'DependencyManager']
+
+
+def __getattr__(name):
+    # Offline assembly does not need a filesystem observer. Keep the public
+    # watcher exports, loading their platform dependency only when requested.
+    if name in ('ProjectWatcher', 'FileWatcher'):
+        from . import watcher
+        value = getattr(watcher, name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f'module {__name__!r} has no attribute {name!r}')

mcpywrap_core/builders/assembly.py

@@ -0,0 +1,100 @@
+"""完整构建和增量更新共用相同的文件合并规则。"""
+import os
+import shutil
+from pathlib import Path
+
+from ..dependencies import DependencyError, canonical_path
+from .AddonsPack import MANIFEST_FILES
+from .file_merge import try_merge_file
+from ..code_libraries import library_source
+
+MERGED_JSON = {'blocks.json', 'terrain_texture.json', 'item_texture.json', 'sounds.json',
+               'sound_definitions.json', 'animations.json', 'animation_controllers.json',
+               'entity_models.json', 'render_controllers.json', 'materials.json',
+               'attachables.json', 'particle_effects.json', '_ui_defs.json'}
+
+
+def is_within(path, parent):
+    try:
+        return os.path.commonpath([canonical_path(path), canonical_path(parent)]) == canonical_path(parent)
+    except ValueError:
+        return False
+
+
+def validate_target(target, root, packs):
+    if not target:
+        raise DependencyError('未指定构建输出目录')
+    # 根目录下的独立 build 允许存在，但不能覆盖任意源包或依赖项目。
+    if is_within(root, target):
+        raise DependencyError(f'构建输出会覆盖主项目: {target}')
+    for pack in packs:
+        protected = [pack.path] if not pack.is_origin else [pack.behavior_pack_dir, pack.resource_pack_dir]
+        for source in filter(None, protected):
+            if is_within(source, target) or is_within(target, source):
+                raise DependencyError(f'构建输出与源目录重叠: {target} <-> {source}')
+
+
+def pack_files(pack, kind):
+    if kind == 'behavior':
+        for library in getattr(pack, 'code_libraries', []):
+            for file in sorted(library['source'].rglob('*')):
+                if file.is_file():
+                    yield library['target'] + '/' + file.relative_to(library['source']).as_posix()
+    folder = getattr(pack, kind + '_pack_dir')
+    if not folder or not os.path.isdir(folder):
+        return
+    for current, dirs, files in os.walk(folder):
+        dirs[:] = sorted(d for d in dirs if not pack.should_exclude(os.path.join(current, d)))
+        for name in sorted(files):
+            source = Path(current) / name
+            if name in MANIFEST_FILES or not pack.should_exclude(str(source)):
+                yield source.relative_to(folder).as_posix()
+
+
+def rebuild_file(packs, kind, relative, destination):
+    """按依赖优先序重建单个产物；所有来源删除后同步删除产物。"""
+    destination = Path(destination)
+    if destination.is_file() or destination.is_symlink():
+        destination.unlink()
+    sources = []
+    for pack in packs:
+        folder = getattr(pack, kind + '_pack_dir')
+        if not folder:
+            continue
+        mounted = library_source(pack, kind, relative)
+        source = mounted or Path(folder) / relative
+        if source.is_file() and (mounted or source.name in MANIFEST_FILES or not pack.should_exclude(str(source))):
+            sources.append((pack, source))
+    if relative in MANIFEST_FILES:
+        # 优先保留主包 manifest；主包缺少该包类型时使用最后一个依赖的 manifest。
+        manifest_owner = next((pack for pack in reversed(packs)
+                               if getattr(pack, kind + '_pack_dir') and any(
+                                   (Path(getattr(pack, kind + '_pack_dir')) / name).is_file()
+                                   for name in MANIFEST_FILES)), None)
+        sources = [(pack, source) for pack, source in sources if pack is manifest_owner]
+    for pack, source in sources:
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        if destination.exists() and (source.name in MERGED_JSON or source.suffix == '.lang'):
+            success, error = try_merge_file(str(source), str(destination))
+            if not success:
+                raise DependencyError(error)
+        elif source.suffix == '.py':
+            pack._copy_with_encoding_check(str(source), str(destination))
+        else:
+            shutil.copy2(source, destination)
+
+
+def assemble_addon(packs, target_pack):
+    for kind in ('behavior', 'resource'):
+        target = getattr(target_pack, kind + '_pack_dir')
+        # Empty directories are part of the pack layout too (e.g. entities/).
+        for pack in packs:
+            folder = getattr(pack, kind + '_pack_dir')
+            if not folder or not os.path.isdir(folder):
+                continue
+            for current, dirs, _ in os.walk(folder):
+                dirs[:] = sorted(d for d in dirs if not pack.should_exclude(os.path.join(current, d)))
+                (Path(target) / Path(current).relative_to(folder)).mkdir(parents=True, exist_ok=True)
+        paths = {relative for pack in packs for relative in pack_files(pack, kind)}
+        for relative in sorted(paths):
+            rebuild_file(packs, kind, relative, Path(target) / relative)

mcpywrap_core/builders/dependency_manager.py

@@ -0,0 +1,239 @@
+"""将 Python 包与本地目录解析为统一的 Addon 依赖图。"""
+import hashlib
+import json
+import re
+from importlib import metadata
+from functools import cached_property
+from pathlib import Path
+from urllib.parse import urlsplit
+from urllib.request import url2pathname
+
+from packaging.requirements import Requirement, InvalidRequirement
+from packaging.utils import canonicalize_name
+from ..dependencies import (DependencyError, DependencyStatus, addon_directories, canonical_path,
+                            declarations, read_project, resolve_path, validate_game_files)
+from .AddonsPack import AddonsPack
+
+
+def _decode_direct_url(direct_url_path):
+    return _local_url(json.loads(Path(direct_url_path).read_text(encoding='utf-8')).get('url', ''))
+
+
+def _local_url(url):
+    parsed = urlsplit(url)
+    if parsed.scheme != 'file':
+        return None
+    path = url2pathname(parsed.path)
+    if parsed.netloc and parsed.netloc != 'localhost':
+        path = '//' + parsed.netloc + path
+    return str(Path(path).resolve())
+
+
+class DependencyNode:
+    def __init__(self, name, addon_pack, parent=None, *, source=None):
+        self.name, self.addon_pack, self.parent = name, addon_pack, parent
+        self.children = []
+        self.source = source or {'kind': 'local', 'path': str(Path(addon_pack.path).resolve())}
+
+    @cached_property
+    def source_root(self):
+        if self.source['kind'] == 'git':
+            from ..git_cache import read_snapshot
+            return read_snapshot(self.source['git'], self.source['rev'], self.source.get('source_sha256'))
+        return Path(self.addon_pack.path).resolve()
+
+    @property
+    def descriptor_root(self):
+        root = self.source_root
+        if self.source['kind'] == 'git':
+            path = (root / self.source['subdir']).resolve()
+            if not path.is_relative_to(root.resolve()):
+                raise DependencyError('Git描述根越界')
+            from ..source_files import long_path
+            return long_path(path)
+        return root
+
+    def add_child(self, node):
+        if node not in self.children:
+            self.children.append(node)
+
+
+class DependencyManager:
+    def __init__(self):
+        self.dependency_map = {}
+        self.root_node = None
+        self.warnings = []
+        self.errors = []
+        self.statuses = {}
+        self._nodes, self._active, self._ordered = {}, [], []
+        self._git_locks = {}
+        self._git_sources = {}
+        self.collect_errors = False
+        self.has_git_projects = False
+
+    def find_dependency_path(self, package_name):
+        try:
+            dist = metadata.distribution(Requirement(package_name).name)
+        except (metadata.PackageNotFoundError, InvalidRequirement):
+            return None
+        direct = dist.read_text('direct_url.json')
+        return _local_url(json.loads(direct).get('url', '')) if direct else None
+
+    def build_dependency_tree(self, project_name, project_path, dependencies=None, *, config=None, allow_missing=False, git_lock=None, collect_errors=False):
+        self.__init__()
+        self.collect_errors = collect_errors
+        project_path = str(Path(project_path).resolve())
+        if git_lock is not None:
+            self._git_locks[project_path] = git_lock
+        config = read_project(project_path) if config is None else config
+        if dependencies is not None:
+            config.setdefault('project', {})['dependencies'] = dependencies
+        root_id = re.sub(r'[^\w.-]', '_', project_name)[:60] + '_' + hashlib.sha256(canonical_path(project_path).encode('utf-8')).hexdigest()[:12]
+        root = DependencyNode(project_name, AddonsPack(root_id, project_path, is_origin=True))
+        folders = [root.addon_pack.behavior_pack_dir, root.addon_pack.resource_pack_dir]
+        if config.get('tool', {}).get('mcpywrap', {}).get('project_type') == 'map':
+            folders = [Path(project_path) / name for name in ('behavior_packs', 'resource_packs')]
+        validate_game_files(project_path, folders)
+        self.root_node = root
+        key = canonical_path(project_path)
+        self._nodes[key] = root
+        self._active.append(key)
+        self._process(root, config)
+        self._active.pop()
+        self.dependency_map = {canonical_path(n.addon_pack.path): n.addon_pack for n in self._ordered}
+        if self.errors and not (allow_missing or collect_errors):
+            raise DependencyError('\n'.join(self.errors))
+        return root
+
+    def _process(self, parent, config):
+        for entry in declarations(config):
+            source = parent.addon_pack.path
+            try:
+                if entry.kind == 'local':
+                    path = str(resolve_path(source, entry.value))
+                    self._visit(parent, path, Path(path).name)
+                    self._status(source, entry, 'addon')
+                    continue
+                try:
+                    requirement = Requirement(entry.value)
+                except InvalidRequirement as exc:
+                    raise DependencyError(f'无效的 Python 包声明: {entry.value}') from exc
+                if requirement.marker and not requirement.marker.evaluate():
+                    self._status(source, entry, 'inactive', '当前工具 Python 环境不满足环境标记，未启用；不代表游戏兼容性。')
+                    continue
+                try:
+                    dist = metadata.distribution(requirement.name)
+                except metadata.PackageNotFoundError:
+                    self._missing(source, entry.value, '尚未安装')
+                    continue
+                if requirement.specifier and not requirement.specifier.contains(dist.version, prereleases=True):
+                    self._missing(source, entry.value, f'已安装 {dist.version}，不满足版本约束')
+                    continue
+                path = self.find_dependency_path(entry.value)
+                if not path:
+                    self._development_only(source, entry)
+                    continue
+                direct = dist.read_text('direct_url.json')
+                if not Path(path).is_dir() and direct and 'dir_info' in json.loads(direct):
+                    self._missing(source, entry.value, f'安装来源目录不存在: {path}')
+                    continue
+                child_config = read_project(path)
+                has_mcpy = 'mcpywrap' in child_config.get('tool', {})
+                looks_like_addon = Path(path).is_dir() and any(
+                    p.is_dir() and p.name.startswith(('behavior_pack', 'BehaviorPack', 'resource_pack', 'ResourcePack'))
+                    for p in Path(path).iterdir())
+                if has_mcpy or looks_like_addon:
+                    self._visit(parent, path, canonicalize_name(requirement.name), source_kind='package')
+                    self._status(source, entry, 'addon')
+                else:
+                    self._development_only(source, entry)
+            except (DependencyError, OSError, ValueError) as exc:
+                message = f'来源 {source}\n依赖 {entry.value!r}: {exc}'
+                if not self.collect_errors:
+                    raise DependencyError(message) from exc
+                self.errors.append(message)
+        from ..git_projects import resolve_projects
+        try:
+            projects = resolve_projects(parent.addon_pack.path, config,
+                                        self._git_locks.get(str(Path(parent.addon_pack.path).resolve())),
+                                        source_records=self._git_sources)
+            for entry, path, info in projects:
+                self.has_git_projects = True
+                self._visit(parent, str(path), entry['name'])
+        except (DependencyError, OSError, ValueError) as exc:
+            if not self.collect_errors:
+                raise
+            self.errors.append(str(exc))
+
+    def _missing(self, source, value, reason):
+        from ..dependencies import DependencyDeclaration
+        message = f'{source}: {value} {reason}；请显式执行 mcpy add "{value}"'
+        self.errors.append(message)
+        self.warnings.append(message)
+        self._status(source, DependencyDeclaration('package', value), 'unavailable', message)
+
+    def _status(self, source, entry, state, message=''):
+        self.statuses[(canonical_path(source), entry.kind, entry.value)] = DependencyStatus(state, message)
+
+    def status_for(self, source, entry):
+        return self.statuses[(canonical_path(source), entry.kind, entry.value)]
+
+    def _development_only(self, source, entry):
+        message = (f'来源 {source}，依赖 {entry.value!r}: 未识别到可组装内容；'
+                   '仅安装于工具环境，不会被打包或供游戏导入。')
+        self.warnings.append(message)
+        self._status(source, entry, 'development_only', message)
+
+    def _visit(self, parent, path, name, source_kind='local'):
+        key = canonical_path(path)
+        if key in self._active:
+            raise DependencyError('循环依赖: ' + ' -> '.join(self._active + [key]))
+        if key in self._nodes:
+            if source_kind == 'local' and self._nodes[key].source['kind'] == 'package':
+                self._nodes[key].source['kind'] = 'local'
+            parent.add_child(self._nodes[key])
+            return
+        config = read_project(path)
+        if config.get('tool', {}).get('mcpywrap', {}).get('project_type', 'addon') != 'addon':
+            raise DependencyError(f'仅支持 Addon 目录依赖: {path}')
+        folders = addon_directories(path)
+        validate_game_files(path, folders.values())
+        suffix = hashlib.sha256(key.encode('utf-8')).hexdigest()[:12]
+        safe_name = re.sub(r'[^\w.-]', '_', name)[:60] or 'addon'
+        addon = AddonsPack(f'{safe_name}_{suffix}', path)
+        addon.behavior_pack_dir, addon.resource_pack_dir = folders.get('behavior'), folders.get('resource')
+        addon.code_target = config.get('tool', {}).get('mcpywrap', {}).get('_registered_code_target')
+        record = self._git_sources.get(key)
+        source = ({'kind': 'git', 'git': record['source']['git'], 'rev': record['source']['rev'],
+                   'subdir': record['source'].get('subdir', '.'), 'source_sha256': record.get('source_sha256')}
+                  if record else {'kind': source_kind, 'path': str(Path(path).resolve())})
+        node = DependencyNode(name, addon, parent, source=source)
+        self._nodes[key] = node
+        parent.add_child(node)
+        self._active.append(key)
+        config = read_project(path)
+        try:
+            if 'mcpywrap' in config.get('tool', {}):
+                self._process(node, config)
+        finally:
+            self._active.pop()
+        self._ordered.append(node)
+
+    def get_all_dependencies(self):
+        return self.dependency_map
+
+    def get_dependency_tree(self):
+        return self.root_node
+
+
+def find_all_mcpywrap_packages():
+    packages = []
+    for dist in metadata.distributions():
+        try:
+            direct = dist.read_text('direct_url.json')
+            path = _local_url(json.loads(direct).get('url', '')) if direct else None
+            if path and 'mcpywrap' in read_project(path).get('tool', {}):
+                packages.append(dist.metadata['Name'])
+        except (ValueError, OSError):
+            continue
+    return sorted(set(packages))