pycapcut 0.0.1__py3-none-any.whl

tools/extract_all.py

@@ -0,0 +1,256 @@
+ 
+"""
+统一元数据提取脚本
+
+用于从剪映原始数据中提取各种类型的元数据
+替换原来分散在 ignored/meta 中的各个提取脚本
+
+使用方法:
+    python extract_all.py --type fonts --source ignored/meta/fonts.json
+    python extract_all.py --type all  # 提取所有类型
+    python extract_all.py --config config.yaml  # 使用配置文件
+"""
+
+import argparse
+import json
+import yaml
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from .jianying_extractor import (
+    FontExtractor, TextAnimationExtractor, MaskExtractor,
+    FilterExtractor, TransitionExtractor, VideoEffectExtractor, AudioEffectExtractor
+)
+from .code_generator import CodeGenerator, LegacyCodeGenerator
+
+
+class MetadataExtractorManager:
+    """元数据提取管理器"""
+    
+    def __init__(self, config_file: Optional[str] = None):
+        self.config = self._load_config(config_file)
+        self.extractors = self._init_extractors()
+    
+    def _load_config(self, config_file: Optional[str]) -> Dict[str, Any]:
+        """加载配置文件"""
+        default_config = {
+            "data_sources": {
+                "fonts": "ignored/meta/fonts.json",
+                "text_intro": "ignored/meta/text_intro.json", 
+                "text_outro": "ignored/meta/text_outro.json",
+                "text_repeat": "ignored/meta/text_repeat.json",
+                "masks": "ignored/meta/masks.json",
+                "filters": "ignored/meta/视频特效/filters.json",
+                "transitions": "ignored/meta/视频特效/transitions.json",
+                "video_character": "ignored/meta/视频特效/video_character_effect.json",
+                "video_scene": "ignored/meta/视频特效/video_scene_effect.json", 
+                "audio_effects": "ignored/meta/audio_effect.json"
+            },
+            "output_dir": "pyJianYingDraft/metadata",
+            "data_dir": "pyJianYingDraft/data",
+            "legacy_output": "tools/legacy_output"
+        }
+        
+        if config_file and Path(config_file).exists():
+            with open(config_file, 'r', encoding='utf-8') as f:
+                if config_file.endswith('.yaml') or config_file.endswith('.yml'):
+                    user_config = yaml.safe_load(f)
+                else:
+                    user_config = json.load(f)
+            
+            # 合并配置
+            default_config.update(user_config)
+        
+        return default_config
+    
+    def _init_extractors(self) -> Dict[str, Any]:
+        """初始化提取器"""
+        sources = self.config["data_sources"]
+        return {
+            "fonts": FontExtractor,
+            "text_intro": TextAnimationExtractor,
+            "text_outro": TextAnimationExtractor, 
+            "text_repeat": TextAnimationExtractor,
+            "masks": MaskExtractor,
+            "filters": FilterExtractor,
+            "transitions": TransitionExtractor,
+            "video_character": VideoEffectExtractor,
+            "video_scene": VideoEffectExtractor,
+            "audio_effects": AudioEffectExtractor
+        }
+    
+    def extract_single_type(self, data_type: str, source_file: Optional[str] = None, 
+                          output_file: Optional[str] = None, legacy_format: bool = False) -> None:
+        """提取单一类型的元数据"""
+        if data_type not in self.extractors:
+            print(f"Error: Unknown data type '{data_type}'")
+            print(f"Available types: {list(self.extractors.keys())}")
+            return
+        
+        # 确定源文件
+        if source_file is None:
+            source_file = self.config["data_sources"].get(data_type)
+            if not source_file:
+                print(f"Error: No source file configured for type '{data_type}'")
+                return
+        
+        source_path = Path(source_file)
+        if not source_path.exists():
+            print(f"Error: Source file not found: {source_path}")
+            return
+        
+        # 确定输出文件
+        if output_file is None:
+            if legacy_format:
+                output_file = f"{self.config['legacy_output']}/{data_type}_meta.py"
+            else:
+                output_file = f"{self.config['data_dir']}/{data_type}.json"
+        
+        # 创建提取器
+        extractor_class = self.extractors[data_type]
+        extractor = extractor_class(source_file, output_file)
+        
+        try:
+            print(f"Extracting {data_type} from {source_file}...")
+            
+            if legacy_format:
+                # 使用旧版格式生成器
+                template_type = self._get_template_type(data_type)
+                LegacyCodeGenerator.generate_from_extractor(extractor, output_file, template_type)
+            else:
+                # 使用新版JSON格式
+                data = extractor.extract()
+                print(f"Successfully extracted {len(data)} items")
+                
+        except Exception as e:
+            print(f"Error extracting {data_type}: {e}")
+    
+    def extract_all(self, legacy_format: bool = False) -> None:
+        """提取所有类型的元数据"""
+        print("Starting extraction of all metadata types...")
+        
+        for data_type in self.extractors.keys():
+            print(f"\n--- Extracting {data_type} ---")
+            try:
+                self.extract_single_type(data_type, legacy_format=legacy_format)
+            except Exception as e:
+                print(f"Failed to extract {data_type}: {e}")
+                continue
+        
+        print("\nExtraction completed!")
+    
+    def generate_code(self, data_type: str, input_file: Optional[str] = None) -> None:
+        """生成Python代码文件"""
+        if input_file is None:
+            input_file = f"{self.config['data_dir']}/{data_type}.json"
+        
+        input_path = Path(input_file)
+        if not input_path.exists():
+            print(f"Error: Input file not found: {input_path}")
+            return
+        
+        # 加载数据
+        with open(input_path, 'r', encoding='utf-8') as f:
+            data_list = json.load(f)
+        
+        import pandas as pd
+        data = pd.DataFrame(data_list)
+        
+        # 生成代码
+        generator = CodeGenerator(data, data_type)
+        
+        # 确定类名和输出文件
+        class_mapping = {
+            "fonts": ("FontType", "font_meta.py", "EffectEnum", "EffectMeta"),
+            "text_intro": ("IntroType", "animation_meta.py", "EffectEnum", "Animation_meta"),
+            "text_outro": ("OutroType", "animation_meta.py", "EffectEnum", "Animation_meta"), 
+            "text_repeat": ("GroupAnimationType", "animation_meta.py", "EffectEnum", "Animation_meta"),
+            "masks": ("MaskType", "mask_meta.py", "EffectEnum", "EffectMeta"),
+            "filters": ("FilterType", "filter_meta.py", "EffectEnum", "EffectMeta"),
+            "transitions": ("TransitionType", "transition_meta.py", "EffectEnum", "Transition_meta"),
+            "video_character": ("VideoCharacterEffectType", "video_effect_meta.py", "EffectEnum", "EffectMeta"),
+            "video_scene": ("VideoSceneEffectType", "video_effect_meta.py", "EffectEnum", "EffectMeta"),
+            "audio_effects": ("ToneEffectType", "audio_effect_meta.py", "EffectEnum", "Audio_effect_meta")
+        }
+        
+        if data_type in class_mapping:
+            class_name, filename, base_class, meta_class = class_mapping[data_type]
+            output_file = f"{self.config['output_dir']}/{filename}"
+            generator.save_to_file(output_file, class_name, base_class, meta_class)
+        else:
+            print(f"Error: No code generation mapping for type '{data_type}'")
+    
+    def _get_template_type(self, data_type: str) -> str:
+        """获取模板类型"""
+        mapping = {
+            "fonts": "font",
+            "text_intro": "animation",
+            "text_outro": "animation",
+            "text_repeat": "animation", 
+            "masks": "effect",
+            "filters": "effect",
+            "transitions": "transition",
+            "video_character": "effect",
+            "video_scene": "effect",
+            "audio_effects": "audio_effect"
+        }
+        return mapping.get(data_type, "effect")
+    
+    def cleanup_legacy_files(self) -> None:
+        """清理旧版提取脚本生成的文件"""
+        legacy_patterns = [
+            "ignored/meta/extract_*.py",
+            "ignored/meta/video_effect_meta.py",
+            "ignored/meta/metadata.py"
+        ]
+        
+        print("Cleaning up legacy files...")
+        cleaned_count = 0
+        
+        for pattern in legacy_patterns:
+            for file_path in Path(".").glob(pattern):
+                if file_path.is_file():
+                    file_path.unlink()
+                    print(f"Removed: {file_path}")
+                    cleaned_count += 1
+        
+        print(f"Cleaned up {cleaned_count} legacy files")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="剪映元数据提取工具")
+    parser.add_argument("--type", choices=["fonts", "text_intro", "text_outro", "text_repeat", 
+                                          "masks", "filters", "transitions", "video_character", 
+                                          "video_scene", "audio_effects", "all"],
+                       help="要提取的数据类型")
+    parser.add_argument("--source", help="源数据文件路径")
+    parser.add_argument("--output", help="输出文件路径")
+    parser.add_argument("--config", help="配置文件路径")
+    parser.add_argument("--legacy", action="store_true", help="使用旧版格式输出")
+    parser.add_argument("--generate-code", help="从JSON数据生成Python代码")
+    parser.add_argument("--cleanup", action="store_true", help="清理旧版文件")
+    
+    args = parser.parse_args()
+    
+    if not any([args.type, args.generate_code, args.cleanup]):
+        parser.print_help()
+        return
+    
+    manager = MetadataExtractorManager(args.config)
+    
+    if args.cleanup:
+        manager.cleanup_legacy_files()
+        return
+    
+    if args.generate_code:
+        manager.generate_code(args.generate_code)
+        return
+    
+    if args.type == "all":
+        manager.extract_all(legacy_format=args.legacy)
+    else:
+        manager.extract_single_type(args.type, args.source, args.output, legacy_format=args.legacy)
+
+
+if __name__ == "__main__":
+    main()

tools/extractor_base.py

@@ -0,0 +1,132 @@
+"""
+元数据提取器基类
+定义统一的提取接口和通用功能
+"""
+
+import json
+import pandas as pd
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Any, Optional, Union
+
+
+@dataclass
+class ExtractorConfig:
+    """提取器配置"""
+    source_file: Union[str, Path]
+    """源数据文件路径"""
+
+    output_file: Optional[Union[str, Path]] = None
+    """输出文件路径，如果为None则不自动保存"""
+
+    sort_by: List[str] = field(default_factory=lambda: ["is_vip", "name"])
+    """排序字段"""
+
+    dedup_by: str = "resource_id"
+    """去重字段"""
+
+    name_field: str = "title"
+    """名称字段"""
+
+
+class MetadataExtractor(ABC):
+    """元数据提取器基类"""
+
+    def __init__(self, config: ExtractorConfig):
+        self.config = config
+        self.raw_data: List[Dict[str, Any]] = []
+        self.processed_data: pd.DataFrame = pd.DataFrame()
+
+    def extract(self) -> pd.DataFrame:
+        """执行完整的提取流程"""
+        self.load_source_data()
+        self.raw_data = self.parse_json_data()
+        self.processed_data = self.process_data()
+
+        if self.config.output_file:
+            self.save_output()
+
+        return self.processed_data
+
+    def load_source_data(self) -> None:
+        """加载源数据文件"""
+        with open(self.config.source_file, 'r', encoding='utf-8') as f:
+            self.source_content = f.readlines()
+
+    @abstractmethod
+    def parse_json_data(self) -> List[Dict[str, Any]]:
+        """解析JSON数据，提取所需字段"""
+        pass
+
+    @abstractmethod
+    def extract_item_data(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """从单个item中提取数据"""
+        pass
+
+    def process_data(self) -> pd.DataFrame:
+        """处理数据：排序、去重等"""
+        df = pd.DataFrame(self.raw_data)
+
+        if len(df) == 0:
+            return df
+
+        # 排序
+        if self.config.sort_by:
+            available_cols = [col for col in self.config.sort_by if col in df.columns]
+            if available_cols:
+                df = df.sort_values(by=available_cols, ascending=True)
+
+        # 去重
+        if self.config.dedup_by and self.config.dedup_by in df.columns:
+            df = df.drop_duplicates(subset=[self.config.dedup_by])
+
+        return df.reset_index(drop=True)
+
+    @abstractmethod
+    def save_output(self) -> None:
+        """保存输出文件"""
+        pass
+
+    @staticmethod
+    def pad_to_length(s: str, length: int, pad_char: str = " ") -> str:
+        """字符串填充，考虑中文字符宽度"""
+        non_ascii_count = sum(1 for c in s if ord(c) > 127)
+        return s.ljust(length - non_ascii_count, pad_char)
+
+    @staticmethod
+    def safe_json_loads(json_str: str, default: Any = None) -> Any:
+        """安全解析JSON字符串"""
+        try:
+            if not json_str:
+                return default or {}
+            return json.loads(json_str)
+        except (json.JSONDecodeError, TypeError):
+            return default or {}
+
+    @staticmethod
+    def clean_identifier(name: str) -> str:
+        """清理标识符名称，用于Python变量名"""
+        cleaned = name.replace(' ', '_').replace('-', '_').replace('.', '_')
+        # 如果以数字开头，添加下划线前缀
+        if cleaned and cleaned[0].isdigit():
+            cleaned = "_" + cleaned
+        return cleaned
+
+    def extract_common_fields(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """提取通用字段"""
+        common_attr = item.get("common_attr", {})
+        business_info = self.safe_json_loads(
+            common_attr.get("business_info", {}).get("json_str", "{}"), {}
+        )
+
+        return {
+            "name": common_attr.get(self.config.name_field, ""),
+            "title": common_attr.get("title", ""),
+            "is_vip": business_info.get("is_vip", False),
+            "resource_id": common_attr.get("id", ""),
+            "effect_id": common_attr.get("effect_id", ""),
+            "md5": common_attr.get("md5", ""),
+            "common_attr": common_attr,
+            "business_info": business_info
+        }

tools/jianying_extractor.py

@@ -0,0 +1,262 @@
+"""
+剪映元数据提取器
+实现剪映特定的数据提取逻辑
+"""
+
+import json
+from typing import Dict, List, Any
+from .extractor_base import MetadataExtractor, ExtractorConfig
+
+
+class JianYingExtractor(MetadataExtractor):
+    """剪映通用提取器"""
+
+    def __init__(self, config: ExtractorConfig, data_type: str = "general"):
+        super().__init__(config)
+        self.data_type = data_type
+
+    def parse_json_data(self) -> List[Dict[str, Any]]:
+        """解析剪映JSON数据格式"""
+        rows = []
+
+        for line in self.source_content:
+            line = line.strip()
+            if not line:
+                continue
+
+            try:
+                # 解析JSON数据
+                data = json.loads(line)
+
+                # 提取effect_item_list
+                effect_items = data.get("data", {}).get("effect_item_list", [])
+
+                # 遍历effect_items并提取所需属性
+                for item in effect_items:
+                    item_data = self.extract_item_data(item)
+                    if item_data:
+                        rows.append(item_data)
+
+            except json.JSONDecodeError:
+                print(f"Warning: Failed to parse line: {line[:100]}...")
+                continue
+
+        return rows
+
+    def extract_item_data(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """提取item数据，子类可重写以处理特定格式"""
+        return self.extract_common_fields(item)
+
+    def save_output(self) -> None:
+        """保存为JSON格式"""
+        output_data = self.processed_data.to_dict('records')
+
+        with open(self.config.output_file, 'w', encoding='utf-8') as f:
+            json.dump(output_data, f, ensure_ascii=False, indent=2)
+
+        print(f"Saved {len(output_data)} items to {self.config.output_file}")
+
+
+class FontExtractor(JianYingExtractor):
+    """字体提取器"""
+
+    def __init__(self, source_file: str, output_file: str = None):
+        config = ExtractorConfig(
+            source_file=source_file,
+            output_file=output_file,
+            sort_by=["is_vip", "title"],
+            name_field="title"
+        )
+        super().__init__(config, "fonts")
+
+
+class TextAnimationExtractor(JianYingExtractor):
+    """文本动画提取器"""
+
+    def __init__(self, source_file: str, output_file: str = None):
+        config = ExtractorConfig(
+            source_file=source_file,
+            output_file=output_file,
+            sort_by=["is_vip", "name"],
+            name_field="title"
+        )
+        super().__init__(config, "text_animations")
+
+    def extract_item_data(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """提取文本动画特定数据"""
+        base_data = super().extract_item_data(item)
+
+        # 文本动画使用name字段而不是title
+        base_data["name"] = base_data["title"]
+
+        return base_data
+
+
+class MaskExtractor(JianYingExtractor):
+    """蒙版提取器"""
+
+    def __init__(self, source_file: str, output_file: str = None):
+        config = ExtractorConfig(
+            source_file=source_file,
+            output_file=output_file,
+            sort_by=["is_vip", "name"],
+            name_field="title"
+        )
+        super().__init__(config, "masks")
+
+    def extract_item_data(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """提取蒙版特定数据"""
+        base_data = super().extract_item_data(item)
+        base_data["name"] = base_data["title"]
+        return base_data
+
+
+class FilterExtractor(JianYingExtractor):
+    """滤镜提取器"""
+
+    def __init__(self, source_file: str, output_file: str = None):
+        config = ExtractorConfig(
+            source_file=source_file,
+            output_file=output_file,
+            sort_by=["is_vip", "title"],
+            name_field="title"
+        )
+        super().__init__(config, "filters")
+
+    def extract_item_data(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """提取滤镜特定数据"""
+        base_data = super().extract_item_data(item)
+
+        # 提取参数信息
+        sdk_extra = self.safe_json_loads(
+            base_data["common_attr"].get("sdk_extra", "{}"), {}
+        )
+        param_list = sdk_extra.get("setting", {}).get("effect_adjust_params", [])
+
+        base_data["params"] = [
+            [param["effect_key"], param["default"], param["min"], param["max"]]
+            for param in param_list
+        ]
+
+        return base_data
+
+
+class TransitionExtractor(JianYingExtractor):
+    """转场提取器"""
+
+    def __init__(self, source_file: str, output_file: str = None):
+        config = ExtractorConfig(
+            source_file=source_file,
+            output_file=output_file,
+            sort_by=["is_vip", "name"],
+            name_field="title"
+        )
+        super().__init__(config, "transitions")
+
+    def extract_item_data(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """提取转场特定数据"""
+        base_data = super().extract_item_data(item)
+
+        # 提取转场特定信息
+        sdk_extra = self.safe_json_loads(
+            base_data["common_attr"].get("sdk_extra", "{}"), {}
+        )
+        transition_info = sdk_extra.get("transition", {})
+
+        base_data.update({
+            "name": base_data["title"],
+            "default_duration": transition_info.get("defaultDura", 1.0),
+            "is_overlap": transition_info.get("isOverlap", False)
+        })
+
+        return base_data
+
+
+class VideoEffectExtractor(JianYingExtractor):
+    """视频特效提取器"""
+
+    def __init__(self, source_file: str, output_file: str = None):
+        config = ExtractorConfig(
+            source_file=source_file,
+            output_file=output_file,
+            sort_by=["is_vip", "title"],
+            name_field="title"
+        )
+        super().__init__(config, "video_effects")
+
+    def extract_item_data(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """提取视频特效特定数据"""
+        base_data = super().extract_item_data(item)
+
+        # 提取参数信息
+        sdk_extra = self.safe_json_loads(
+            base_data["common_attr"].get("sdk_extra", "{}"), {}
+        )
+        param_list = sdk_extra.get("setting", {}).get("effect_adjust_params", [])
+
+        base_data["params"] = [
+            [param["effect_key"], param["default"], param["min"], param["max"]]
+            for param in param_list
+        ]
+
+        return base_data
+
+
+class AudioEffectExtractor(JianYingExtractor):
+    """音频特效提取器"""
+
+    def __init__(self, source_file: str, output_file: str = None):
+        config = ExtractorConfig(
+            source_file=source_file,
+            output_file=output_file,
+            sort_by=["is_vip", "effect_name"],
+            name_field="name"
+        )
+        super().__init__(config, "audio_effects")
+
+    def parse_json_data(self) -> List[Dict[str, Any]]:
+        """解析音频特效的特殊JSON格式"""
+        rows = []
+
+        try:
+            # 音频特效是单个JSON文件，不是按行的JSON
+            content = "".join(self.source_content)
+            data = json.loads(content)
+
+            # 提取effects列表
+            effect_items = data.get("data", {}).get("effects", [])
+
+            for item in effect_items:
+                item_data = self.extract_item_data(item)
+                if item_data:
+                    rows.append(item_data)
+
+        except json.JSONDecodeError as e:
+            print(f"Error parsing audio effects JSON: {e}")
+
+        return rows
+
+    def extract_item_data(self, item: Dict[str, Any]) -> Dict[str, Any]:
+        """提取音频特效特定数据"""
+        extra = self.safe_json_loads(item.get("extra", "{}"), {})
+
+        # 只提取"音色"类型的特效
+        if "is_voice_conversion" not in extra:
+            return None
+
+        # 提取参数信息
+        sdk_extra = self.safe_json_loads(item.get("sdk_extra", "{}"), {})
+        param_list = sdk_extra.get("setting", {}).get("audio_effect_parameters_change", [])
+
+        return {
+            "effect_name": item.get("name", ""),
+            "name": item.get("name", ""),
+            "is_vip": extra.get("is_vip", False),
+            "resource_id": item.get("resource_id", ""),
+            "effect_id": item.get("effect_id", ""),
+            "md5": item.get("id", ""),
+            "params": [
+                [param["sliderName"], param["defaultValue"], param["minValue"], param["maxValue"]]
+                for param in param_list
+            ]
+        }