mcpywrap 0.1.0__tar.gz

mcpywrap-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: mcpywrap
+Version: 0.1.0
+Summary: A wrapper for Minecraft China Edition Addons management
+Author-email: boybook <boybook@easecation.net>
+License: MIT
+Project-URL: Homepage, https://github.com/EaseCation/mcpywrap
+Project-URL: Bug Tracker, https://github.com/EaseCation/mcpywrap/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: 3to2>=1.1.1
+Requires-Dist: watchdog>=2.0.0
+Requires-Dist: twine>=3.4.0
+Requires-Dist: tomli
+Requires-Dist: tomli-w
+Requires-Dist: setuptools
+Requires-Dist: PyQt5>=5.15.0
+
+# 🧰 mcpywrap 
+
+**《我的世界》中国版 ModSDK 与资源包的全周期管理工具**
+
+[![PyPI Version](https://img.shields.io/pypi/v/mcpywrap)](https://pypi.org/project/mcpywrap/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+mcpywrap 是基于 Python 生态的《我的世界》中国版 ModSDK/资源包全周期管理工具，支持依赖管理、语法转换和自动化构建，助力开发者实现高效协作与代码复用。
+
+## 🌟 核心特性
+
+- 🧩 **模块化开发** - 基于 Addons 维度的依赖管理
+- 🔄 **语法无忧** - 开发阶段支持 Python3 语法，构建时自动转换为 Python2
+- 📦 **生态兼容** - 无缝对接 PyPI 生态，支持标准 `pyproject.toml` 配置
+- 🚀 **智能构建** - 一键打包符合 MCStudio 规范的成品 Addons
+- 🔥 **热重载开发** - 实时监控代码变更，支持 MCStudio 热更新
+
+## 📖 为何选择此工具？
+
+### 传统开发痛点
+- 📜 **代码复用困难** - 通过 **文件拷贝** 导致版本管理混乱
+- 🚧 **协作效率低下** - 多项目 **重复代码** 维护成本高
+- ⚠️ **语法限制** - 中国版仅支持 Python2，缺乏现代语法支持
+
+### mcpywrap 解决方案
+1. **标准化开发**  
+通过 `pyproject.toml` 声明项目元数据和依赖关系，实现真正的模块化开发
+
+2. **现代开发体验**  
+开发阶段使用 Python3 语法，构建时通过 3to2 自动转换，兼顾开发效率与运行兼容
+
+3. **生态集成**  
+依托 pip 包管理体系，支持依赖的版本锁定和自动解析
+
+
+## 🚀 快速开始
+
+### 前置要求
+- Python ≥ 3.8
+- pip ≥ 21.0
+
+### 安装
+```bash
+pip install mcpywrap
+```
+
+### 初始化项目
+```bash
+mcpy init
+```
+交互式创建项目结构，自动生成标准的 Mod 框架。
+
+## 🛠 工作流指南
+
+### 依赖管理
+| 命令                          | 说明                  |
+|-------------------------------|---------------------|
+| `mcpy`                 | 维护项目，将项目安装到系统 site-package 环境            |
+| `mcpy add <package> [version]` | 添加指定版本依赖          |
+| `mcpy remove <package>`        | 移除依赖               |
+
+### 构建与开发
+```bash
+# 生产构建（输出到配置的 build 目录）
+mcpy build
+
+# 开发模式（热重载 + 实时构建）
+mcpy dev
+```
+
+## 🤝 参与贡献
+欢迎提交 Issue 和 PR！请先阅读 [贡献指南](CONTRIBUTING.md)。
+
+## 开源协议
+[MIT License](LICENSE) © 2025 EaseCation

mcpywrap-0.1.0/README.md

@@ -0,0 +1,75 @@
+# 🧰 mcpywrap 
+
+**《我的世界》中国版 ModSDK 与资源包的全周期管理工具**
+
+[![PyPI Version](https://img.shields.io/pypi/v/mcpywrap)](https://pypi.org/project/mcpywrap/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+mcpywrap 是基于 Python 生态的《我的世界》中国版 ModSDK/资源包全周期管理工具，支持依赖管理、语法转换和自动化构建，助力开发者实现高效协作与代码复用。
+
+## 🌟 核心特性
+
+- 🧩 **模块化开发** - 基于 Addons 维度的依赖管理
+- 🔄 **语法无忧** - 开发阶段支持 Python3 语法，构建时自动转换为 Python2
+- 📦 **生态兼容** - 无缝对接 PyPI 生态，支持标准 `pyproject.toml` 配置
+- 🚀 **智能构建** - 一键打包符合 MCStudio 规范的成品 Addons
+- 🔥 **热重载开发** - 实时监控代码变更，支持 MCStudio 热更新
+
+## 📖 为何选择此工具？
+
+### 传统开发痛点
+- 📜 **代码复用困难** - 通过 **文件拷贝** 导致版本管理混乱
+- 🚧 **协作效率低下** - 多项目 **重复代码** 维护成本高
+- ⚠️ **语法限制** - 中国版仅支持 Python2，缺乏现代语法支持
+
+### mcpywrap 解决方案
+1. **标准化开发**  
+通过 `pyproject.toml` 声明项目元数据和依赖关系，实现真正的模块化开发
+
+2. **现代开发体验**  
+开发阶段使用 Python3 语法，构建时通过 3to2 自动转换，兼顾开发效率与运行兼容
+
+3. **生态集成**  
+依托 pip 包管理体系，支持依赖的版本锁定和自动解析
+
+
+## 🚀 快速开始
+
+### 前置要求
+- Python ≥ 3.8
+- pip ≥ 21.0
+
+### 安装
+```bash
+pip install mcpywrap
+```
+
+### 初始化项目
+```bash
+mcpy init
+```
+交互式创建项目结构，自动生成标准的 Mod 框架。
+
+## 🛠 工作流指南
+
+### 依赖管理
+| 命令                          | 说明                  |
+|-------------------------------|---------------------|
+| `mcpy`                 | 维护项目，将项目安装到系统 site-package 环境            |
+| `mcpy add <package> [version]` | 添加指定版本依赖          |
+| `mcpy remove <package>`        | 移除依赖               |
+
+### 构建与开发
+```bash
+# 生产构建（输出到配置的 build 目录）
+mcpy build
+
+# 开发模式（热重载 + 实时构建）
+mcpy dev
+```
+
+## 🤝 参与贡献
+欢迎提交 Issue 和 PR！请先阅读 [贡献指南](CONTRIBUTING.md)。
+
+## 开源协议
+[MIT License](LICENSE) © 2025 EaseCation

mcpywrap-0.1.0/mcpywrap/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""mcpywrap - 将 Python 3 代码转换为 Python 2 代码的工具"""
+
+__version__ = '0.1.0'

mcpywrap-0.1.0/mcpywrap/__main__.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+"""
+mcpywrap 命令行工具的入口点
+"""
+
+from .cli import cli
+
+def main():
+    """主函数，作为 CLI 入口点"""
+    cli()
+
+if __name__ == "__main__":
+    main()

mcpywrap-0.1.0/mcpywrap/builders/AddonsPack.py

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+
+import os
+import shutil
+import click
+from .file_handler import ensure_dir, try_merge_file
+
+
+# Python 包管理和其他应该忽略的文件和目录
+EXCLUDED_PATTERNS = [
+    # Python 包管理
+    ".egg-info",
+    "__pycache__",
+    ".pyc",
+    ".pyo",
+    ".pyd",
+    ".so",
+    ".dll",
+    ".eggs",
+    ".pytest_cache",
+    ".tox",
+    ".coverage",
+    ".coverage.*",
+    "htmlcov",
+    # 版本控制
+    ".git",
+    ".hg",
+    ".svn",
+    ".bzr",
+    # 其他临时文件
+    ".DS_Store",
+    "Thumbs.db"
+]
+
+MANIFEST_FILES = [
+    "manifest.json",
+    "pack_manifest.json"
+]
+
+
+class AddonsPack(object):
+
+    pkg_name: str
+    path: str
+    is_origin: bool
+    behavior_pack_dir: str
+    resource_pack_dir: str
+
+    def __init__(self, pkg_name, path, is_origin=False):
+        self.pkg_name = pkg_name
+        self.path = path
+        self.is_origin = is_origin
+        self.behavior_pack_dir = None
+        self.resource_pack_dir = None
+        # 进入此目录，查找内部的行为包和资源包的路径
+        os.chdir(self.path)
+        for item in os.listdir(self.path):
+            item_path = os.path.join(self.path, item)
+            if os.path.isdir(item_path):
+                if item.startswith("behavior_pack") or item.startswith("BehaviorPack"):
+                    self.behavior_pack_dir = item_path
+                elif item.startswith("resource_pack") or item.startswith("ResourcePack"):
+                    self.resource_pack_dir = item_path
+        if not self.behavior_pack_dir:
+            self.behavior_pack_dir = os.path.join(self.path, "behavior_pack")
+        if not self.resource_pack_dir:
+            self.resource_pack_dir = os.path.join(self.path, "resource_pack")
+
+    def should_exclude(self, path):
+        """判断文件或目录是否应该被排除"""
+        for pattern in EXCLUDED_PATTERNS:
+            if pattern in path:
+                return True
+        # 得到文件名
+        filename = os.path.basename(path)
+        if not self.is_origin and filename in MANIFEST_FILES:
+            return True
+        return False
+
+    def copy_behavior_to(self, target_dir: str):
+        """复制行为包和资源包到目标目录"""
+        if self.behavior_pack_dir:
+            target_path = os.path.join(target_dir, os.path.basename(self.behavior_pack_dir))
+            os.makedirs(target_path, exist_ok=True)
+
+            # 使用自定义复制函数而不是shutil.copytree
+            for root, dirs, files in os.walk(self.behavior_pack_dir):
+                # 过滤掉应该排除的目录
+                dirs[:] = [d for d in dirs if not self.should_exclude(os.path.join(root, d))]
+
+                # 计算相对路径
+                rel_path = os.path.relpath(root, self.behavior_pack_dir)
+                # 计算目标目录
+                target_root = os.path.join(target_path, rel_path) if rel_path != '.' else target_path
+                ensure_dir(target_root)
+
+                # 复制文件
+                for file in files:
+                    src_file = os.path.join(root, file)
+                    if not self.should_exclude(src_file):
+                        dest_file = os.path.join(target_root, file)
+                        # 如果是Python文件，检查并添加编码声明
+                        if file.endswith('.py'):
+                            self._copy_with_encoding_check(src_file, dest_file)
+                        else:
+                            shutil.copy2(src_file, dest_file)
+
+    def copy_resource_to(self, target_dir: str):
+        """复制资源包到目标目录"""
+        if self.resource_pack_dir:
+            target_path = os.path.join(target_dir, os.path.basename(self.resource_pack_dir))
+            os.makedirs(target_path, exist_ok=True)
+
+            # 使用自定义复制函数而不是shutil.copytree
+            for root, dirs, files in os.walk(self.resource_pack_dir):
+                # 过滤掉应该排除的目录
+                dirs[:] = [d for d in dirs if not self.should_exclude(os.path.join(root, d))]
+
+                # 计算相对路径
+                rel_path = os.path.relpath(root, self.resource_pack_dir)
+                # 计算目标目录
+                target_root = os.path.join(target_path, rel_path) if rel_path != '.' else target_path
+                ensure_dir(target_root)
+
+                # 复制文件
+                for file in files:
+                    src_file = os.path.join(root, file)
+                    if not self.should_exclude(src_file):
+                        dest_file = os.path.join(target_root, file)
+                        # 如果是Python文件，检查并添加编码声明
+                        if file.endswith('.py'):
+                            self._copy_with_encoding_check(src_file, dest_file)
+                        else:
+                            shutil.copy2(src_file, dest_file)
+
+    def merge_behavior_into(self, target_behavior_dir: str):
+        """合并行为包到目标行为包目录"""
+        if self.behavior_pack_dir:
+            for root, dirs, files in os.walk(self.behavior_pack_dir):
+                # 过滤掉应该排除的目录
+                dirs[:] = [d for d in dirs if not self.should_exclude(os.path.join(root, d))]
+
+                # 计算相对路径
+                rel_path = os.path.relpath(root, self.behavior_pack_dir)
+                # 计算目标目录
+                target_root = os.path.join(target_behavior_dir, rel_path) if rel_path != '.' else target_behavior_dir
+                ensure_dir(target_root)
+
+                # 复制文件
+                for file in files:
+                    src_file = os.path.join(root, file)
+                    if self.should_exclude(src_file):
+                        continue
+
+                    dest_file = os.path.join(target_root, file)
+
+                    if file.endswith('.py'):  # 如果是Python文件，直接无脑覆盖
+                        self._copy_with_encoding_check(src_file, dest_file)
+                    elif os.path.exists(dest_file):  # 如果文件已存在，尝试合并
+                        suc, reason = try_merge_file(src_file, dest_file)
+                        if not suc:
+                            click.secho(f"❌ 未处理的文件冲突: {src_file} -> {dest_file} {reason}", fg="red")
+                    else:
+                        shutil.copy2(src_file, dest_file)
+
+    def merge_resource_into(self, target_resource_dir: str):
+        """合并资源包到目标资源包目录"""
+        if self.resource_pack_dir:
+            for root, dirs, files in os.walk(self.resource_pack_dir):
+                # 过滤掉应该排除的目录
+                dirs[:] = [d for d in dirs if not self.should_exclude(os.path.join(root, d))]
+
+                # 计算相对路径
+                rel_path = os.path.relpath(root, self.resource_pack_dir)
+                # 计算目标目录
+                target_root = os.path.join(target_resource_dir, rel_path) if rel_path != '.' else target_resource_dir
+                ensure_dir(target_root)
+
+                # 复制文件
+                for file in files:
+                    src_file = os.path.join(root, file)
+                    if self.should_exclude(src_file):
+                        continue
+
+                    dest_file = os.path.join(target_root, file)
+                    # 处理文件冲突
+                    if file.endswith('.py'):
+                        self._copy_with_encoding_check(src_file, dest_file)
+                    elif os.path.exists(dest_file):
+                        suc, reason = try_merge_file(src_file, dest_file)
+                        if not suc:
+                            click.secho(f"⚠️ 警告: 文件合并异常 {src_file} -> {dest_file} {reason}", fg="yellow")
+                            # 如果是Python文件，检查并添加编码声明
+                            if file.endswith('.py'):
+                                self._copy_with_encoding_check(src_file, dest_file)
+                            else:
+                                shutil.copy2(src_file, dest_file)
+                    else:
+                        shutil.copy2(src_file, dest_file)
+
+    def _copy_with_encoding_check(self, src_file, dest_file):
+        """复制Python文件，并检查添加编码声明"""
+        try:
+            with open(src_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+
+            # 检查是否有编码声明
+            has_coding = False
+            first_line = content.splitlines()[0] if content.splitlines() else ""
+            if "# -*- coding: utf-8 -*-" in first_line or "# coding: utf-8" in first_line:
+                has_coding = True
+
+            # 如果没有编码声明，则添加
+            if not has_coding:
+                content = "# -*- coding: utf-8 -*-\n" + content
+
+            # 写入目标文件
+            with open(dest_file, 'w', encoding='utf-8') as f:
+                f.write(content)
+
+            # 复制文件元数据
+            shutil.copystat(src_file, dest_file)
+        except Exception as e:
+            click.secho(f"⚠️ 添加编码声明时出错: {src_file} -> {dest_file}: {str(e)}", fg="yellow")
+            # 如果出错，则直接复制
+            shutil.copy2(src_file, dest_file)

mcpywrap-0.1.0/mcpywrap/builders/__init__.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+构建模块包，提供项目构建、文件处理和监控功能
+"""
+
+from .project_builder import build_project
+from .file_handler import process_file, is_python_file
+from .watcher import FileWatcher
+
+__all__ = ['build_project', 'process_file', 'is_python_file', 'FileWatcher']

mcpywrap-0.1.0/mcpywrap/builders/file_handler.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+"""
+文件处理模块 - 负责单个文件的复制和转换
+"""
+
+import os
+import shutil
+
+from ..utils.py3to2_util import py3_to_2
+from ..utils.utils import ensure_dir, run_command
+from .file_merge import try_merge_file
+
+def is_python_file(file_path):
+    """判断是否为Python文件"""
+    return file_path.endswith('.py')
+
+def copy_file(src_path, dest_path):
+    """复制文件，确保目标目录存在"""
+    dest_dir = os.path.dirname(dest_path)
+    ensure_dir(dest_dir)
+    print(f"复制文件: {src_path} 到 {dest_path}")
+    shutil.copy2(src_path, dest_path)
+    return dest_path
+
+def convert_py3_to_py2(file_path):
+    """将某个Python文件转换为Python 2"""
+    try:
+        # 首先尝试使用直接的Python API调用
+        from lib3to2.main import main
+        # main函数接受包名和参数列表
+        # 第一个参数是包名 'lib3to2' (这是3to2所有修复器的位置)
+        # 第二个参数是命令行参数列表
+        exit_code = main('lib3to2.fixes', ['-w', '-n', '--no-diffs', file_path, '--nofix=metaclass'])
+        # exit_code = py3_to_2(file_path)
+        return exit_code == 0, "转换完成" if exit_code == 0 else f"转换失败，错误代码: {exit_code}"
+    except Exception as e:
+        # 如果直接调用失败，则尝试命令行方式（作为备选）
+        try:
+            # 方法1：直接命令行调用
+            success, output = run_command(["3to2", "-w", "-n", file_path])
+            if not success:
+                # 方法2：使用shell=True参数
+                success, output = run_command(["3to2", "-w", "-n", file_path], shell=True)
+            
+            return success, output
+        except Exception as cmd_e:
+            return False, f"Python API调用失败: {str(e)}\n命令行调用也失败: {str(cmd_e)}"
+
+def process_file(src_path, source_dir, target_dir, is_dependency=False, dependency_name=None):
+    """处理单个文件（复制并根据文件类型处理）"""
+    # 计算相对路径和目标路径
+    rel_path = os.path.relpath(src_path, source_dir)
+    
+    # 如果是依赖项，需要特殊处理目标路径
+    if is_dependency:
+        # 确定是属于行为包还是资源包
+        if "behavior_pack" in src_path.lower() or "behaviorpack" in src_path.lower():
+            # 在路径中定位behavior_pack部分
+            parts = src_path.split(os.sep)
+            for i, part in enumerate(parts):
+                if "behavior_pack" in part.lower() or "behaviorpack" in part.lower():
+                    # 获取behavior_pack后的相对路径
+                    sub_path = os.path.join(*parts[i+1:])
+                    # 目标路径应该是behavior_pack目录
+                    for item in os.listdir(target_dir):
+                        if "behavior_pack" in item.lower() or "behaviorpack" in item.lower():
+                            dest_path = os.path.join(target_dir, item, sub_path)
+                            break
+                    else:
+                        # 如果找不到behavior_pack目录，创建一个
+                        dest_path = os.path.join(target_dir, "behavior_pack", sub_path)
+                    break
+        elif "resource_pack" in src_path.lower() or "resourcepack" in src_path.lower():
+            # 在路径中定位resource_pack部分
+            parts = src_path.split(os.sep)
+            for i, part in enumerate(parts):
+                if "resource_pack" in part.lower() or "resourcepack" in part.lower():
+                    # 获取resource_pack后的相对路径
+                    sub_path = os.path.join(*parts[i+1:])
+                    # 目标路径应该是resource_pack目录
+                    for item in os.listdir(target_dir):
+                        if "resource_pack" in item.lower() or "resourcepack" in item.lower():
+                            dest_path = os.path.join(target_dir, item, sub_path)
+                            break
+                    else:
+                        # 如果找不到resource_pack目录，创建一个
+                        dest_path = os.path.join(target_dir, "resource_pack", sub_path)
+                    break
+        else:
+            # 如果不在行为包或资源包中，忽略该文件
+            return False, "不在行为包或资源包中的文件将被忽略", None
+    else:
+        dest_path = os.path.join(target_dir, rel_path)
+
+    # 检查目标文件是否已存在，如果存在且来自依赖，尝试合并
+    if is_dependency and os.path.exists(dest_path):
+        suc, reason = try_merge_file(src_path, dest_path)
+        if not suc:
+            # 如果合并失败或有冲突，直接返回
+            msg = f"文件合并失败或存在冲突" if reason is None else reason
+            return False, msg, dest_path
+    else:
+        # 复制文件
+        copy_file(src_path, dest_path)
+
+    # 如果是Python文件，进行转换
+    if is_python_file(src_path):
+        success, output = convert_py3_to_py2(dest_path)
+        return success, output, dest_path
+
+    # 如果是其他类型文件，直接返回成功
+    return True, "", dest_path

mcpywrap-0.1.0/mcpywrap/builders/file_merge.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+import os
+import shutil
+
+
+def try_merge_file(source_file, target_file) -> tuple[bool, str]:
+    """合并两个JSON文件的内容"""
+    # 如果是py文件，直接复制即可
+    if source_file.endswith('.py'):
+        # 直接复制
+        shutil.copy2(source_file, target_file)
+        return True, f"成功复制 {os.path.basename(source_file)}"
+    else:
+        # 读取源文件内容
+        with open(source_file, 'r', encoding='utf-8') as f:
+            source_content = f.read()
+
+        # 读取目标文件内容
+        with open(target_file, 'r', encoding='utf-8') as f:
+            target_content = f.read()
+
+        # 合并两个JSON对象
+        try:
+            source_json = eval(source_content)
+            target_json = eval(target_content)
+            merged_json = _merge_dicts(target_json, source_json)
+
+            # 写入合并后的内容到目标文件
+            with open(target_file, 'w', encoding='utf-8') as f:
+                f.write(str(merged_json))
+
+            return True, f"成功合并 {os.path.basename(source_file)} 到 {os.path.basename(target_file)}"
+        except Exception as e:
+            return False, f"合并失败: {str(e)}"
+
+def _merge_dicts(dict1, dict2):
+    """递归合并两个字典"""
+    result = dict1.copy()
+    for key, value in dict2.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            # 递归合并嵌套字典
+            result[key] = _merge_dicts(result[key], value)
+        elif key in result and isinstance(result[key], list) and isinstance(value, list):
+            # 合并列表
+            result[key].extend(value)
+        else:
+            # 覆盖或添加新键
+            result[key] = value
+    return result