tretool 0.3.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

tretool/__init__.py

@@ -34,6 +34,8 @@ if sys.version_info >= MIN_PY_VERSION:
     from . import timelib
     from . import transform
 
+    from . import ziplib
+
 else:
     current_version = f"{sys.version_info.major}.{sys.version_info.minor}"
     required_version = f"{MIN_PY_VERSION[0]}.{MIN_PY_VERSION[1]}"

tretool/transform/docx.py

@@ -0,0 +1,544 @@
+import os
+import sys
+import logging
+import time
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Union, List, Optional, Dict, Callable
+from concurrent.futures import ThreadPoolExecutor
+from functools import wraps, lru_cache
+import argparse
+
+# 第三方库导入
+try:
+    from docx import Document
+    from docx.shared import Pt, RGBColor
+    from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+    from PIL import Image
+    import pandas as pd
+except ImportError as e:
+    print(f"缺少依赖库: {e}")
+    sys.exit(1)
+
+# 日志配置
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(),
+        logging.FileHandler('docx_processor.log')
+    ]
+)
+
+# 自定义异常
+class DocxProcessingError(Exception):
+    """基础处理异常"""
+    pass
+
+class DocxPermissionError(DocxProcessingError):
+    """DOCX权限错误"""
+    pass
+
+class DocxCorruptedError(DocxProcessingError):
+    """DOCX文件损坏"""
+    pass
+
+class UnsupportedFormatError(DocxProcessingError):
+    """不支持的格式"""
+    pass
+
+class DocxProcessor(ABC):
+    """
+    DOCX文档处理器抽象基类
+    
+    提供DOCX文档处理的基础功能，包括:
+    - 文件路径验证
+    - 输出路径处理
+    - 基本错误处理
+    
+    子类应实现:
+    - process() 方法: 执行实际处理逻辑
+    - supported_operations() 类方法: 返回支持的操作列表
+    """
+    
+    def __init__(self, docx_path: Union[str, Path]):
+        """
+        初始化DOCX处理器
+        
+        参数:
+            docx_path: DOCX文件路径
+        """
+        self.docx_path = Path(docx_path)
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self._progress_callback = None
+        
+        # 验证文件
+        if not self.docx_path.exists():
+            raise FileNotFoundError(f"DOCX文件不存在: {docx_path}")
+        if self.docx_path.suffix.lower() != '.docx':
+            raise ValueError("输入文件必须是DOCX格式")
+        
+        self.logger.info(f"初始化处理器，处理文件: {docx_path}")
+
+    @abstractmethod
+    def process(self, output_path: Union[str, Path], **kwargs) -> Union[str, List[str]]:
+        """
+        处理DOCX文档
+        
+        参数:
+            output_path: 输出文件路径
+            **kwargs: 处理选项
+            
+        返回:
+            处理后的文件路径或路径列表
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def supported_operations(cls) -> List[str]:
+        """返回支持的操作列表"""
+        return []
+
+    def set_progress_callback(self, callback: Callable[[int, int], None]):
+        """设置进度回调函数"""
+        self._progress_callback = callback
+        
+    def _update_progress(self, current: int, total: int):
+        """更新进度"""
+        if self._progress_callback:
+            self._progress_callback(current, total)
+
+    def get_metadata(self) -> Dict[str, str]:
+        """获取DOCX元数据"""
+        try:
+            doc = Document(self.docx_path)
+            return {
+                'title': doc.core_properties.title,
+                'author': doc.core_properties.author,
+                'created': str(doc.core_properties.created),
+                'modified': str(doc.core_properties.modified),
+                'paragraphs': len(doc.paragraphs),
+                'tables': len(doc.tables)
+            }
+        except Exception as e:
+            self.logger.warning(f"获取元数据失败: {str(e)}")
+            return {}
+
+    def _prepare_output_path(self, output_path: Union[str, Path], 
+                           default_extension: str) -> Path:
+        """
+        准备输出路径
+        
+        参数:
+            output_path: 输出路径
+            default_extension: 默认文件扩展名
+            
+        返回:
+            处理后的Path对象
+        """
+        output_path = Path(output_path)
+        
+        # 如果是目录，自动生成文件名
+        if output_path.is_dir():
+            output_path = output_path / f"{self.docx_path.stem}.{default_extension}"
+        # 如果没有扩展名，添加默认扩展名
+        elif not output_path.suffix:
+            output_path = output_path.with_suffix(f".{default_extension}")
+            
+        # 创建父目录（如果不存在）
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        return output_path
+
+# 重试装饰器
+def retry(max_attempts=3, delay=1, exceptions=(Exception,)):
+    def decorator(f):
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            last_error = None
+            for attempt in range(1, max_attempts+1):
+                try:
+                    return f(*args, **kwargs)
+                except exceptions as e:
+                    last_error = e
+                    if attempt < max_attempts:
+                        time.sleep(delay)
+            raise last_error
+        return wrapper
+    return decorator
+
+# 具体处理器实现
+class DocxToPDFConverter(DocxProcessor):
+    @retry(max_attempts=3, delay=0.5)
+    def process(self, output_path: Union[str, Path], **kwargs) -> str:
+        """
+        将DOCX转换为PDF
+        
+        参数:
+            output_path: 输出文件路径
+            **kwargs:
+                - pages: 要转换的页码范围(如'1-3,5')
+                - quality: 输出质量(high/medium/low)
+                
+        返回:
+            转换后的文件路径
+        """
+        try:
+            output_path = self._prepare_output_path(output_path, 'pdf')
+            
+            # 尝试使用docx2pdf库
+            try:
+                from docx2pdf import convert
+                convert(str(self.docx_path), str(output_path))
+                return str(output_path)
+            except ImportError:
+                self.logger.warning("docx2pdf未安装，尝试使用unoconv")
+                # 回退到unoconv
+                try:
+                    import subprocess
+                    subprocess.run(['unoconv', '-f', 'pdf', '-o', str(output_path), str(self.docx_path)], check=True)
+                    return str(output_path)
+                except Exception as e:
+                    raise DocxProcessingError(f"转换为PDF失败，请安装docx2pdf或unoconv: {str(e)}")
+        except Exception as e:
+            raise DocxProcessingError(f"转换为PDF失败: {str(e)}")
+
+    @classmethod
+    def supported_operations(cls) -> List[str]:
+        return ['pdf']
+
+class DocxToTextConverter(DocxProcessor):
+    @retry(max_attempts=3, delay=0.5)
+    def process(self, output_path: Union[str, Path], **kwargs) -> str:
+        """
+        将DOCX转换为纯文本
+        
+        参数:
+            output_path: 输出文件路径
+            **kwargs:
+                - include_tables: 是否包含表格内容(True/False)
+                - encoding: 文本编码(默认utf-8)
+                
+        返回:
+            转换后的文件路径
+        """
+        try:
+            output_path = self._prepare_output_path(output_path, 'txt')
+            include_tables = kwargs.get('include_tables', False)
+            encoding = kwargs.get('encoding', 'utf-8')
+            
+            doc = Document(self.docx_path)
+            text = []
+            
+            for para in doc.paragraphs:
+                text.append(para.text)
+            
+            if include_tables:
+                for table in doc.tables:
+                    for row in table.rows:
+                        for cell in row.cells:
+                            text.append(cell.text)
+            
+            with open(output_path, 'w', encoding=encoding) as f:
+                f.write('\n'.join(text))
+            
+            return str(output_path)
+        except Exception as e:
+            raise DocxProcessingError(f"转换为文本失败: {str(e)}")
+
+    @classmethod
+    def supported_operations(cls) -> List[str]:
+        return ['txt']
+
+class DocxToHTMLConverter(DocxProcessor):
+    @retry(max_attempts=3, delay=0.5)
+    def process(self, output_path: Union[str, Path], **kwargs) -> str:
+        """
+        将DOCX转换为HTML
+        
+        参数:
+            output_path: 输出文件路径
+            **kwargs:
+                - css: 自定义CSS样式
+                - include_images: 是否包含图像(True/False)
+                
+        返回:
+            转换后的HTML文件路径
+        """
+        try:
+            output_path = self._prepare_output_path(output_path, 'html')
+            
+            # 尝试使用pandoc
+            try:
+                import subprocess
+                subprocess.run([
+                    'pandoc', '-s', str(self.docx_path), 
+                    '-o', str(output_path), 
+                    '--css', kwargs.get('css', '')
+                ], check=True)
+                return str(output_path)
+            except Exception:
+                self.logger.warning("pandoc不可用，使用基本转换")
+                # 基本实现
+                doc = Document(self.docx_path)
+                html_content = [
+                    '<!DOCTYPE html>',
+                    '<html>',
+                    '<head>',
+                    '<meta charset="UTF-8">',
+                    f'<title>{self.docx_path.stem}</title>',
+                    f'<style>{kwargs.get("css", "body { font-family: Arial; }")}</style>',
+                    '</head>',
+                    '<body>'
+                ]
+                
+                for para in doc.paragraphs:
+                    html_content.append(f'<p>{para.text}</p>')
+                
+                html_content.extend(['</body>', '</html>'])
+                
+                with open(output_path, 'w', encoding='utf-8') as f:
+                    f.write('\n'.join(html_content))
+                
+                return str(output_path)
+        except Exception as e:
+            raise DocxProcessingError(f"转换为HTML失败: {str(e)}")
+
+    @classmethod
+    def supported_operations(cls) -> List[str]:
+        return ['html']
+
+class DocxToCSVConverter(DocxProcessor):
+    @retry(max_attempts=3, delay=0.5)
+    def process(self, output_path: Union[str, Path], **kwargs) -> Union[str, List[str]]:
+        """
+        提取DOCX中的表格为CSV
+        
+        参数:
+            output_path: 输出文件路径或目录
+            **kwargs:
+                - table_indexes: 要提取的表格索引列表(如[0,2])
+                - encoding: CSV文件编码(默认utf-8)
+                
+        返回:
+            单个CSV文件路径或多个CSV文件路径列表
+        """
+        try:
+            table_indexes = kwargs.get('table_indexes', None)
+            encoding = kwargs.get('encoding', 'utf-8')
+            
+            doc = Document(self.docx_path)
+            tables = doc.tables
+            
+            if not tables:
+                raise DocxProcessingError("未找到表格数据")
+            
+            if table_indexes is None:
+                table_indexes = range(len(tables))
+            
+            output_path = Path(output_path)
+            if len(table_indexes) == 1:
+                output_path = self._prepare_output_path(output_path, 'csv')
+                df = self._table_to_dataframe(tables[table_indexes[0]])
+                df.to_csv(output_path, index=False, encoding=encoding)
+                return str(output_path)
+            else:
+                output_path.mkdir(parents=True, exist_ok=True)
+                output_files = []
+                for i in table_indexes:
+                    if i < len(tables):
+                        table_path = output_path / f"table_{i}.csv"
+                        df = self._table_to_dataframe(tables[i])
+                        df.to_csv(table_path, index=False, encoding=encoding)
+                        output_files.append(str(table_path))
+                return output_files
+        except Exception as e:
+            raise DocxProcessingError(f"提取表格失败: {str(e)}")
+    
+    def _table_to_dataframe(self, table) -> pd.DataFrame:
+        """将Word表格转换为DataFrame"""
+        data = []
+        for row in table.rows:
+            row_data = []
+            for cell in row.cells:
+                row_data.append(cell.text)
+            data.append(row_data)
+        return pd.DataFrame(data)
+
+    @classmethod
+    def supported_operations(cls) -> List[str]:
+        return ['csv']
+
+class DocxEditor(DocxProcessor):
+    """DOCX文档编辑器"""
+    @retry(max_attempts=3, delay=0.5)
+    def process(self, output_path: Union[str, Path], **kwargs) -> str:
+        """
+        编辑DOCX文档
+        
+        参数:
+            output_path: 输出文件路径
+            **kwargs:
+                - replace: 替换字典 {旧文本: 新文本}
+                - add_watermark: 水印文本
+                - font_size: 字体大小(默认12)
+                - font_color: 字体颜色(十六进制，如#FF0000)
+                
+        返回:
+            编辑后的文件路径
+        """
+        try:
+            output_path = self._prepare_output_path(output_path, 'docx')
+            
+            doc = Document(self.docx_path)
+            
+            # 文本替换
+            if 'replace' in kwargs:
+                for old_text, new_text in kwargs['replace'].items():
+                    for para in doc.paragraphs:
+                        if old_text in para.text:
+                            para.text = para.text.replace(old_text, new_text)
+            
+            # 添加水印
+            if 'add_watermark' in kwargs:
+                watermark = kwargs['add_watermark']
+                font_size = kwargs.get('font_size', 12)
+                font_color = kwargs.get('font_color', '#C0C0C0')
+                
+                for section in doc.sections:
+                    header = section.header
+                    paragraph = header.paragraphs[0] if header.paragraphs else header.add_paragraph()
+                    paragraph.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+                    
+                    run = paragraph.add_run(watermark)
+                    run.font.size = Pt(font_size)
+                    run.font.color.rgb = RGBColor(*self._hex_to_rgb(font_color))
+            
+            doc.save(output_path)
+            return str(output_path)
+        except Exception as e:
+            raise DocxProcessingError(f"编辑文档失败: {str(e)}")
+    
+    def _hex_to_rgb(self, hex_color: str) -> tuple:
+        """十六进制颜色转RGB"""
+        hex_color = hex_color.lstrip('#')
+        return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+
+    @classmethod
+    def supported_operations(cls) -> List[str]:
+        return ['edit']
+
+# 工厂类
+class DocxProcessorFactory:
+    _operation_map = {
+        'pdf': (DocxToPDFConverter, 'PDF文档'),
+        'txt': (DocxToTextConverter, '纯文本文件'),
+        'html': (DocxToHTMLConverter, 'HTML网页'),
+        'csv': (DocxToCSVConverter, 'CSV表格数据'),
+        'edit': (DocxEditor, '文档编辑')
+    }
+
+    @staticmethod
+    @lru_cache(maxsize=32)
+    def get_processor(operation: str, docx_path: str) -> DocxProcessor:
+        """
+        获取指定操作的处理器
+        
+        参数:
+            operation: 操作类型
+            docx_path: DOCX文件路径
+            
+        返回:
+            DocxProcessor实例
+            
+        抛出:
+            UnsupportedOperationError: 当操作不支持时
+        """
+        operation = operation.lower()
+        if operation not in DocxProcessorFactory._operation_map:
+            raise UnsupportedFormatError(f"不支持的操作: {operation}")
+        
+        return DocxProcessorFactory._operation_map[operation][0](docx_path)
+
+    @staticmethod
+    def get_supported_operations() -> Dict[str, str]:
+        """获取所有支持的操作及其描述"""
+        return {op: desc for op, (_, desc) in DocxProcessorFactory._operation_map.items()}
+
+# 命令行接口
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='DOCX文档处理工具 - 支持多种格式转换和编辑',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    parser.add_argument('input', help='输入DOCX文件路径')
+    parser.add_argument('output', help='输出文件路径或目录')
+    parser.add_argument('-o', '--operation', required=True, 
+                       choices=DocxProcessorFactory.get_supported_operations().keys(),
+                       help='操作类型')
+    parser.add_argument('--pages', help='页码范围(仅PDF转换)')
+    parser.add_argument('--quality', choices=['high', 'medium', 'low'], 
+                       default='medium', help='输出质量(仅PDF转换)')
+    parser.add_argument('--include-tables', action='store_true',
+                       help='包含表格内容(仅文本转换)')
+    parser.add_argument('--table-indexes', help='要提取的表格索引(如0,2,3)')
+    parser.add_argument('--replace', nargs=2, action='append',
+                       metavar=('OLD', 'NEW'), help='文本替换(编辑操作)')
+    parser.add_argument('--watermark', help='水印文本(编辑操作)')
+    parser.add_argument('--font-size', type=int, default=12,
+                       help='水印字体大小(编辑操作)')
+    parser.add_argument('--font-color', default='#C0C0C0',
+                       help='水印字体颜色(十六进制，编辑操作)')
+    return parser.parse_args()
+
+def main():
+    args = parse_args()
+    
+    try:
+        # 获取处理器
+        processor = DocxProcessorFactory.get_processor(args.operation, args.input)
+        
+        # 准备参数
+        kwargs = {}
+        if args.operation == 'pdf':
+            kwargs.update({
+                'pages': args.pages,
+                'quality': args.quality
+            })
+        elif args.operation == 'txt':
+            kwargs['include_tables'] = args.include_tables
+        elif args.operation == 'csv':
+            if args.table_indexes:
+                kwargs['table_indexes'] = [int(i) for i in args.table_indexes.split(',')]
+        elif args.operation == 'edit':
+            if args.replace:
+                kwargs['replace'] = dict(args.replace)
+            if args.watermark:
+                kwargs['add_watermark'] = args.watermark
+                kwargs['font_size'] = args.font_size
+                kwargs['font_color'] = args.font_color
+        
+        # 设置进度回调
+        def progress_callback(current, total):
+            print(f"\r进度: {current}/{total} ({current/total:.1%})", end='', flush=True)
+        processor.set_progress_callback(progress_callback)
+        
+        # 执行处理
+        print(f"开始处理: {args.input} -> {args.output} ({args.operation})")
+        result = processor.process(args.output, **kwargs)
+        
+        print("\n处理成功!")
+        if isinstance(result, list):
+            print(f"生成文件 {len(result)} 个:")
+            for file in result:
+                print(f"  - {file}")
+        else:
+            print(f"输出文件: {result}")
+            
+    except Exception as e:
+        print(f"\n处理失败: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

tretool/ziplib.py

@@ -0,0 +1,664 @@
+"""
+secure_zip.py - 支持加密的ZIP文件操作库
+
+功能：
+1. 支持AES加密(128/192/256位)和传统PKWARE加密
+2. 创建/解压加密ZIP文件
+3. 查看加密ZIP内容
+4. 完整性检查
+"""
+
+import os
+import struct
+import zlib
+import shutil
+import hashlib
+import random
+from typing import List, Union, Optional, Dict, BinaryIO, Tuple
+from pathlib import Path
+from dataclasses import dataclass
+from datetime import datetime
+from Crypto.Cipher import AES
+from Crypto.Util.Padding import pad, unpad
+from Crypto.Random import get_random_bytes
+
+# ZIP文件格式常量
+ZIP_SIGNATURE = b'PK\x03\x04'
+ZIP_CENTRAL_DIR_SIGNATURE = b'PK\x01\x02'
+ZIP_END_OF_CENTRAL_DIR_SIGNATURE = b'PK\x05\x06'
+
+# 加密相关常量
+COMPRESSION_STORED = 0
+COMPRESSION_DEFLATED = 8
+ENCRYPTION_TRADITIONAL = 0x01
+ENCRYPTION_AES128 = 0x02
+ENCRYPTION_AES192 = 0x03
+ENCRYPTION_AES256 = 0x04
+AES_BLOCK_SIZE = 16
+AES_SALT_SIZE = 16
+AES_PASSWORD_VERIFIER_SIZE = 2
+AES_MAC_SIZE = 10
+AES_KEY_LENGTHS = {
+    ENCRYPTION_AES128: 16,
+    ENCRYPTION_AES192: 24,
+    ENCRYPTION_AES256: 32
+}
+
+@dataclass
+class ZipFileHeader:
+    version: int
+    flags: int
+    compression: int
+    mod_time: int
+    mod_date: int
+    crc32: int
+    compressed_size: int
+    uncompressed_size: int
+    filename: str
+    extra: bytes
+    file_offset: int
+    is_encrypted: bool = False
+    encryption_method: int = 0
+    aes_strength: int = 0
+    salt: bytes = b''
+    password_verifier: bytes = b''
+
+class SecureZipFile:
+    def __init__(self, filename: Union[str, Path], mode: str = 'r', password: Optional[str] = None):
+        """
+        初始化加密ZIP文件对象
+        
+        参数:
+            filename: ZIP文件路径
+            mode: 打开模式 ('r'读取, 'w'写入, 'a'追加)
+            password: 加密密码(可选)
+        """
+        self.filename = Path(filename)
+        self.mode = mode
+        self.password = password
+        self.file_headers: Dict[str, ZipFileHeader] = {}
+        self.fp: Optional[BinaryIO] = None
+        
+        if mode == 'r':
+            self._read_zip_file()
+        elif mode == 'w':
+            self.fp = open(self.filename, 'wb')
+        elif mode == 'a':
+            if self.filename.exists():
+                self._read_zip_file()
+                self.fp = open(self.filename, 'r+b')
+                # 定位到中央目录前
+                self.fp.seek(self.end_of_central_dir_offset)
+            else:
+                self.fp = open(self.filename, 'wb')
+        else:
+            raise ValueError("Invalid mode, must be 'r', 'w' or 'a'")
+
+    def _read_zip_file(self):
+        """读取ZIP文件并解析文件头信息"""
+        if not self.filename.exists():
+            raise FileNotFoundError(f"ZIP file not found: {self.filename}")
+        
+        self.fp = open(self.filename, 'rb')
+        self._find_end_of_central_dir()
+        self._read_central_directory()
+    
+    def _find_end_of_central_dir(self):
+        """定位并读取ZIP文件尾部的中央目录结束记录"""
+        file_size = self.filename.stat().st_size
+        max_comment_len = 65535
+        search_size = min(file_size, max_comment_len + 22)
+        
+        self.fp.seek(file_size - search_size)
+        data = self.fp.read()
+        
+        pos = data.rfind(ZIP_END_OF_CENTRAL_DIR_SIGNATURE)
+        if pos < 0:
+            raise ValueError("Not a valid ZIP file (end of central directory signature not found)")
+        
+        end_record = data[pos:pos+22]
+        (
+            self.disk_number,
+            self.central_dir_disk,
+            self.disk_entries,
+            self.total_entries,
+            self.central_dir_size,
+            self.central_dir_offset,
+            self.comment_length
+        ) = struct.unpack('<HHHHIIH', end_record[4:22])
+        
+        self.end_of_central_dir_offset = file_size - (search_size - pos)
+    
+    def _read_central_directory(self):
+        """读取中央目录并解析文件头信息"""
+        self.fp.seek(self.central_dir_offset)
+        
+        while True:
+            signature = self.fp.read(4)
+            if signature != ZIP_CENTRAL_DIR_SIGNATURE:
+                break
+                
+            header_data = self.fp.read(42)
+            (
+                version_made_by, version_needed, flags, compression,
+                mod_time, mod_date, crc32, compressed_size, uncompressed_size,
+                filename_len, extra_len, comment_len, disk_num_start,
+                internal_attrs, external_attrs, local_header_offset
+            ) = struct.unpack('<HHHHHHIIIHHHHHII', header_data)
+            
+            filename = self.fp.read(filename_len).decode('utf-8')
+            extra = self.fp.read(extra_len)
+            comment = self.fp.read(comment_len)
+            
+            is_encrypted = (flags & 0x1) != 0
+            encryption_method = 0
+            aes_strength = 0
+            salt = b''
+            password_verifier = b''
+            
+            if is_encrypted:
+                # 检查AES加密标志
+                if (flags & 0x40) != 0:
+                    # AES加密
+                    encryption_method = (flags >> 8) & 0xFF
+                    aes_strength = AES_KEY_LENGTHS.get(encryption_method, 0)
+                    
+                    # 从额外字段中读取salt和验证器
+                    extra_pos = 0
+                    while extra_pos < len(extra):
+                        header_id, data_size = struct.unpack_from('<HH', extra, extra_pos)
+                        extra_pos += 4
+                        if header_id == 0x9901:  # AE-x ID
+                            aes_data = extra[extra_pos:extra_pos+data_size]
+                            if len(aes_data) >= 7:
+                                aes_version, vendor_id, strength = struct.unpack_from('<HBB', aes_data, 0)
+                                salt = aes_data[7:7+AES_SALT_SIZE]
+                                password_verifier = aes_data[7+AES_SALT_SIZE:7+AES_SALT_SIZE+AES_PASSWORD_VERIFIER_SIZE]
+                            break
+                        extra_pos += data_size
+                else:
+                    # 传统PKWARE加密
+                    encryption_method = ENCRYPTION_TRADITIONAL
+            
+            # 保存文件头信息
+            self.file_headers[filename] = ZipFileHeader(
+                version=version_needed,
+                flags=flags,
+                compression=compression,
+                mod_time=mod_time,
+                mod_date=mod_date,
+                crc32=crc32,
+                compressed_size=compressed_size,
+                uncompressed_size=uncompressed_size,
+                filename=filename,
+                extra=extra,
+                file_offset=local_header_offset,
+                is_encrypted=is_encrypted,
+                encryption_method=encryption_method,
+                aes_strength=aes_strength,
+                salt=salt,
+                password_verifier=password_verifier
+            )
+    
+    def close(self):
+        """关闭ZIP文件"""
+        if self.fp is not None:
+            if self.mode in ('w', 'a'):
+                self._write_central_directory()
+            self.fp.close()
+            self.fp = None
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+    
+    def _generate_aes_key(self, salt: bytes, key_length: int) -> Tuple[bytes, bytes]:
+        """生成AES密钥和验证器"""
+        if not self.password:
+            raise ValueError("Password is required for AES encryption")
+        
+        # 使用PBKDF2生成密钥
+        key = hashlib.pbkdf2_hmac(
+            'sha1',
+            self.password.encode('utf-8'),
+            salt,
+            1000,  # 迭代次数
+            key_length * 2 + 2  # 密钥+MAC密钥+验证器
+        )
+        
+        encryption_key = key[:key_length]
+        mac_key = key[key_length:key_length*2]
+        password_verifier = key[key_length*2:key_length*2+2]
+        
+        return encryption_key, mac_key, password_verifier
+    
+    def _traditional_encrypt(self, data: bytes) -> bytes:
+        """传统PKWARE加密"""
+        if not self.password:
+            raise ValueError("Password is required for traditional encryption")
+        
+        # 初始化加密密钥
+        keys = [0x12345678, 0x23456789, 0x34567890]
+        for c in self.password.encode('utf-8'):
+            keys = self._update_keys(keys, c)
+        
+        # 加密数据
+        encrypted_data = bytearray()
+        for i, b in enumerate(data):
+            c = b ^ self._crc32_crypt_byte(keys[2])
+            encrypted_data.append(c)
+            keys = self._update_keys(keys, c)
+        
+        return bytes(encrypted_data)
+    
+    def _traditional_decrypt(self, data: bytes) -> bytes:
+        """传统PKWARE解密"""
+        if not self.password:
+            raise ValueError("Password is required for traditional decryption")
+        
+        # 初始化加密密钥
+        keys = [0x12345678, 0x23456789, 0x34567890]
+        for c in self.password.encode('utf-8'):
+            keys = self._update_keys(keys, c)
+        
+        # 解密数据
+        decrypted_data = bytearray()
+        for i, b in enumerate(data):
+            c = b ^ self._crc32_crypt_byte(keys[2])
+            decrypted_data.append(c)
+            keys = self._update_keys(keys, c)
+        
+        return bytes(decrypted_data)
+    
+    def _update_keys(self, keys: List[int], c: int) -> List[int]:
+        """更新传统加密密钥"""
+        keys[0] = zlib.crc32(bytes([c]), keys[0]) & 0xFFFFFFFF
+        keys[1] = (keys[1] + (keys[0] & 0xFF)) & 0xFFFFFFFF
+        keys[1] = (keys[1] * 134775813 + 1) & 0xFFFFFFFF
+        keys[2] = zlib.crc32(bytes([keys[1] >> 24]), keys[2]) & 0xFFFFFFFF
+        return keys
+    
+    def _crc32_crypt_byte(self, key: int) -> int:
+        """传统加密的字节加密函数"""
+        temp = (key | 2) & 0xFFFF
+        return ((temp * (temp ^ 1)) >> 8) & 0xFF
+    
+    def _write_central_directory(self):
+        """写入中央目录和结束记录"""
+        if self.fp is None:
+            raise ValueError("ZIP file not open")
+        
+        central_dir_start = self.fp.tell()
+        
+        for header in self.file_headers.values():
+            self.fp.write(ZIP_CENTRAL_DIR_SIGNATURE)
+            self.fp.write(struct.pack(
+                '<HHHHHHIIIHHHHHII',
+                20,         # version made by
+                20,         # version needed to extract
+                header.flags,
+                header.compression,
+                header.mod_time,
+                header.mod_date,
+                header.crc32,
+                header.compressed_size,
+                header.uncompressed_size,
+                len(header.filename.encode('utf-8')),
+                len(header.extra),
+                0,          # file comment length
+                0,          # disk number start
+                0,          # internal file attributes
+                0o644 << 16, # external file attributes
+                header.file_offset
+            ))
+            self.fp.write(header.filename.encode('utf-8'))
+            self.fp.write(header.extra)
+        
+        central_dir_end = self.fp.tell()
+        central_dir_size = central_dir_end - central_dir_start
+        
+        self.fp.write(ZIP_END_OF_CENTRAL_DIR_SIGNATURE)
+        self.fp.write(struct.pack(
+            '<HHHHIIH',
+            0,              # number of this disk
+            0,              # disk where central directory starts
+            len(self.file_headers),
+            len(self.file_headers),
+            central_dir_size,
+            central_dir_start,
+            0               # ZIP file comment length
+        ))
+    
+    def write(self, filename: str, data: bytes, compress: bool = True, 
+              encryption_method: int = 0) -> None:
+        """
+        向ZIP文件中写入一个文件
+        
+        参数:
+            filename: ZIP内的文件名
+            data: 文件数据
+            compress: 是否压缩数据
+            encryption_method: 加密方法 (0=不加密, 1=传统加密, 2=AES128, 3=AES192, 4=AES256)
+        """
+        if self.fp is None or self.mode not in ('w', 'a'):
+            raise ValueError("ZIP file not open for writing")
+        
+        # 计算CRC32校验和
+        crc32 = zlib.crc32(data) & 0xFFFFFFFF
+        
+        if compress:
+            compressed_data = zlib.compress(data)
+            compression = COMPRESSION_DEFLATED
+        else:
+            compressed_data = data
+            compression = COMPRESSION_STORED
+        
+        # 加密数据
+        is_encrypted = encryption_method != 0
+        salt = b''
+        password_verifier = b''
+        extra = b''
+        
+        if is_encrypted:
+            if not self.password:
+                raise ValueError("Password is required for encryption")
+            
+            if encryption_method == ENCRYPTION_TRADITIONAL:
+                # 传统PKWARE加密
+                encrypted_data = self._traditional_encrypt(compressed_data)
+                flags = 0x1  # 加密标志
+            elif encryption_method in (ENCRYPTION_AES128, ENCRYPTION_AES192, ENCRYPTION_AES256):
+                # AES加密
+                key_length = AES_KEY_LENGTHS[encryption_method]
+                salt = get_random_bytes(AES_SALT_SIZE)
+                encryption_key, mac_key, password_verifier = self._generate_aes_key(salt, key_length)
+                
+                # 创建AES加密器
+                cipher = AES.new(encryption_key, AES.MODE_CBC, iv=salt)
+                padded_data = pad(compressed_data, AES_BLOCK_SIZE)
+                encrypted_data = cipher.encrypt(padded_data)
+                
+                # 添加HMAC-SHA1验证码(简化实现)
+                mac = hashlib.sha1(encrypted_data).digest()[:AES_MAC_SIZE]
+                encrypted_data += mac
+                
+                # 设置AES额外字段
+                aes_extra = struct.pack('<HBB', 0x9901, 7, encryption_method - 1)
+                extra = aes_extra + salt + password_verifier
+                flags = 0x41  # 加密标志 + AES标志
+            else:
+                raise ValueError("Unsupported encryption method")
+        else:
+            encrypted_data = compressed_data
+            flags = 0
+        
+        # 记录本地文件头位置
+        file_offset = self.fp.tell()
+        
+        # 写入本地文件头
+        self.fp.write(ZIP_SIGNATURE)
+        self.fp.write(struct.pack(
+            '<HHHHHIII',
+            20,             # version needed to extract
+            flags,          # general purpose bit flag
+            compression,
+            0,              # last mod time (simplified)
+            0,              # last mod date (simplified)
+            crc32,
+            len(encrypted_data),
+            len(data)
+        ))
+        
+        # 写入文件名和额外字段
+        self.fp.write(filename.encode('utf-8'))
+        if extra:
+            self.fp.write(extra)
+        
+        # 写入加密数据
+        self.fp.write(encrypted_data)
+        
+        # 保存文件头信息
+        self.file_headers[filename] = ZipFileHeader(
+            version=20,
+            flags=flags,
+            compression=compression,
+            mod_time=0,
+            mod_date=0,
+            crc32=crc32,
+            compressed_size=len(encrypted_data),
+            uncompressed_size=len(data),
+            filename=filename,
+            extra=extra,
+            file_offset=file_offset,
+            is_encrypted=is_encrypted,
+            encryption_method=encryption_method,
+            aes_strength=AES_KEY_LENGTHS.get(encryption_method, 0),
+            salt=salt,
+            password_verifier=password_verifier
+        )
+    
+    def extract(self, member: str, path: Optional[Union[str, Path]] = None) -> None:
+        """
+        从ZIP文件中提取一个文件
+        
+        参数:
+            member: 要提取的文件名
+            path: 提取目标路径(默认为当前目录)
+        """
+        if self.fp is None or self.mode != 'r':
+            raise ValueError("ZIP file not open for reading")
+        
+        if member not in self.file_headers:
+            raise KeyError(f"File not found in ZIP: {member}")
+        
+        header = self.file_headers[member]
+        target_path = Path(path or '.') / member
+        
+        # 确保目标目录存在
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        # 定位到文件数据
+        self.fp.seek(header.file_offset)
+        signature = self.fp.read(4)
+        if signature != ZIP_SIGNATURE:
+            raise ValueError("Invalid local file header signature")
+        
+        # 读取本地文件头
+        local_header = self.fp.read(26)
+        (
+            version, flags, compression, mod_time, mod_date,
+            crc32, compressed_size, uncompressed_size,
+            filename_len, extra_len
+        ) = struct.unpack('<HHHHHIIIHH', local_header)
+        
+        # 跳过文件名和额外字段
+        filename = self.fp.read(filename_len).decode('utf-8')
+        extra = self.fp.read(extra_len)
+        
+        # 读取加密数据
+        encrypted_data = self.fp.read(compressed_size)
+        
+        # 解密数据
+        if header.is_encrypted:
+            if not self.password:
+                raise ValueError("Password is required for encrypted file")
+            
+            if header.encryption_method == ENCRYPTION_TRADITIONAL:
+                # 传统PKWARE解密
+                decrypted_data = self._traditional_decrypt(encrypted_data)
+            elif header.encryption_method in (ENCRYPTION_AES128, ENCRYPTION_AES192, ENCRYPTION_AES256):
+                # AES解密
+                key_length = header.aes_strength
+                encryption_key, mac_key, password_verifier = self._generate_aes_key(header.salt, key_length)
+                
+                # 验证密码
+                if header.password_verifier != password_verifier:
+                    raise ValueError("Incorrect password")
+                
+                # 分离数据和MAC
+                if len(encrypted_data) < AES_MAC_SIZE:
+                    raise ValueError("Invalid encrypted data length")
+                
+                data_part = encrypted_data[:-AES_MAC_SIZE]
+                mac = encrypted_data[-AES_MAC_SIZE:]
+                
+                # 验证MAC(简化实现)
+                computed_mac = hashlib.sha1(data_part).digest()[:AES_MAC_SIZE]
+                if mac != computed_mac:
+                    raise ValueError("MAC verification failed")
+                
+                # 解密数据
+                cipher = AES.new(encryption_key, AES.MODE_CBC, iv=header.salt)
+                decrypted_padded_data = cipher.decrypt(data_part)
+                decrypted_data = unpad(decrypted_padded_data, AES_BLOCK_SIZE)
+            else:
+                raise ValueError("Unsupported encryption method")
+        else:
+            decrypted_data = encrypted_data
+        
+        # 解压数据
+        if compression == COMPRESSION_STORED:
+            data = decrypted_data
+        elif compression == COMPRESSION_DEFLATED:
+            data = zlib.decompress(decrypted_data)
+        else:
+            raise ValueError(f"Unsupported compression method: {compression}")
+        
+        # 验证CRC32
+        if zlib.crc32(data) & 0xFFFFFFFF != header.crc32:
+            raise ValueError("CRC32 checksum failed")
+        
+        # 写入目标文件
+        with open(target_path, 'wb') as f:
+            f.write(data)
+    
+    def namelist(self) -> List[str]:
+        """返回ZIP文件中所有文件的名称列表"""
+        return list(self.file_headers.keys())
+    
+    def testzip(self) -> Optional[str]:
+        """
+        测试ZIP文件中所有文件的完整性
+        
+        返回:
+            第一个损坏的文件名，如果所有文件都完好则返回None
+        """
+        if self.fp is None or self.mode != 'r':
+            raise ValueError("ZIP file not open for reading")
+        
+        for filename, header in self.file_headers.items():
+            try:
+                self.extract(filename, '/dev/null')  # 尝试提取到虚拟位置
+            except:
+                return filename
+        
+        return None
+
+# 高级API函数
+def create_secure_zip(
+    zip_path: Union[str, Path],
+    files_to_zip: List[Union[str, Path]],
+    password: Optional[str] = None,
+    encryption_method: int = 0,
+    compression: bool = True,
+    overwrite: bool = False
+) -> None:
+    """
+    创建加密的ZIP文件
+    
+    参数:
+        zip_path: 要创建的ZIP文件路径
+        files_to_zip: 要压缩的文件/文件夹列表
+        password: 加密密码
+        encryption_method: 加密方法 (0=不加密, 1=传统加密, 2=AES128, 3=AES192, 4=AES256)
+        compression: 是否压缩数据
+        overwrite: 是否覆盖已存在的ZIP文件
+        
+    异常:
+        FileExistsError: 当ZIP文件已存在且不允许覆盖时
+        FileNotFoundError: 当要压缩的文件不存在时
+        ValueError: 当需要密码但未提供时
+    """
+    zip_path = Path(zip_path)
+    if zip_path.exists() and not overwrite:
+        raise FileExistsError(f"ZIP file already exists: {zip_path}")
+
+    with SecureZipFile(zip_path, 'w', password) as zipf:
+        for item in files_to_zip:
+            item = Path(item)
+            if not item.exists():
+                raise FileNotFoundError(f"File not found: {item}")
+
+            if item.is_file():
+                with open(item, 'rb') as f:
+                    data = f.read()
+                zipf.write(str(item.name), data, compress=compression, encryption_method=encryption_method)
+            elif item.is_dir():
+                for root, _, files in os.walk(item):
+                    for file in files:
+                        file_path = Path(root) / file
+                        rel_path = str(file_path.relative_to(item.parent))
+                        with open(file_path, 'rb') as f:
+                            data = f.read()
+                        zipf.write(rel_path, data, compress=compression, encryption_method=encryption_method)
+
+def extract_secure_zip(
+    zip_path: Union[str, Path],
+    extract_to: Union[str, Path],
+    password: Optional[str] = None,
+    members: Optional[List[str]] = None,
+    overwrite: bool = False
+) -> None:
+    """
+    解压加密的ZIP文件
+    
+    参数:
+        zip_path: ZIP文件路径
+        extract_to: 解压目标目录
+        password: 解密密码
+        members: 可选,只解压指定的文件
+        overwrite: 是否覆盖已存在的文件
+        
+    异常:
+        FileNotFoundError: 当ZIP文件不存在时
+        ValueError: 当ZIP文件损坏或密码错误时
+    """
+    zip_path = Path(zip_path)
+    extract_to = Path(extract_to)
+
+    if not zip_path.exists():
+        raise FileNotFoundError(f"ZIP file not found: {zip_path}")
+
+    if not overwrite:
+        # 检查是否会覆盖已有文件
+        with SecureZipFile(zip_path, 'r', password) as zipf:
+            for member in members or zipf.namelist():
+                dest = extract_to / member
+                if dest.exists():
+                    raise FileExistsError(f"File exists and overwrite=False: {dest}")
+
+    with SecureZipFile(zip_path, 'r', password) as zipf:
+        for member in members or zipf.namelist():
+            zipf.extract(member, extract_to)
+
+def is_encrypted_zip(zip_path: Union[str, Path]) -> bool:
+    """
+    检查ZIP文件是否加密
+    
+    参数:
+        zip_path: ZIP文件路径
+        
+    返回:
+        如果ZIP文件包含加密文件则返回True，否则返回False
+        
+    异常:
+        FileNotFoundError: 当ZIP文件不存在时
+    """
+    zip_path = Path(zip_path)
+    if not zip_path.exists():
+        raise FileNotFoundError(f"ZIP file not found: {zip_path}")
+
+    with SecureZipFile(zip_path, 'r') as zipf:
+        return any(header.is_encrypted for header in zipf.file_headers.values())

{tretool-0.3.0.dist-info → tretool-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tretool
-Version: 0.3.0
+Version: 1.0.0
 Summary: 一个有着许多功能的Python工具库
 Author-email: Jemy <sh_ljr_2013@163.com>
 License-Expression: MIT
@@ -29,4 +29,6 @@ Dynamic: license-file
 
 ### 使用pip
 bash
-```pip install tretool
+```
+pip install tretool
+```

{tretool-0.3.0.dist-info → tretool-1.0.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tretool/__init__.py,sha256=YF1vRE9oYjYim_lkBr6G9fNhP0-OalUarsmaLtUi5qk,1406
+tretool/__init__.py,sha256=l0ufgWz4BFP1WSrnDh80T7GCFOIudoJgXBuwwZYBz54,1434
 tretool/config.py,sha256=Lmu3w5RRjGkX3T36EWdLonztvcKQq0mRvjZ2XU0R01A,16601
 tretool/decoratorlib.py,sha256=Vz3275svoHd28yPZyJFF-uF_oVoKuHPsU-_skMohF0Q,15460
 tretool/encoding.py,sha256=pysRjF-RDw1iVlM6J8yME6EEZTHcB9SnWofNk_B1cog,15341
@@ -12,11 +12,13 @@ tretool/plugin.py,sha256=CacUi_1iapnBVejfmf5vj5oE26-NIAPajVZ2I3QIQt4,20048
 tretool/smartCache.py,sha256=OuH98BsrWC_F-bqhCRomBvFcuVWvfVnc_iyQfZpo_40,18513
 tretool/tasklib.py,sha256=rEME3kt5K2yXAr9gYdl5keBA15Wchm2POluFHBhUwUM,25867
 tretool/timelib.py,sha256=XH1o8WDoj4W41vO-AuRV782d6IuqvmcCuKEkdabHsjg,16559
+tretool/ziplib.py,sha256=tRlaOQDEGETBjl6M4tnQ7Wz-GzQL2bfryLj1rKHa_9s,24742
 tretool/plugin/plu.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tretool/transform/__init__.py,sha256=-0UKgEwky5AAV_UNGSRdKhYbrkAjUHZIO4Lj0z-ITPE,17
+tretool/transform/docx.py,sha256=zWYJxYuHvy4YUcUkuoJHx78qqnWwR7spP1KDltKYFek,19863
 tretool/transform/pdf.py,sha256=rYgXbZDSCx_405KK_FP2ZfiBKVr-EI8wwi_S9-ImHNk,20990
-tretool-0.3.0.dist-info/licenses/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-tretool-0.3.0.dist-info/METADATA,sha256=mkGRII3IIPD5cMbUc8n1Fe5aw8DsZQq-KHLkcnHKVVA,946
-tretool-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tretool-0.3.0.dist-info/top_level.txt,sha256=0kbUVnSHjYxSRD1ziCdpw73ECdl7QysxeNHlRuY9xtc,8
-tretool-0.3.0.dist-info/RECORD,,
+tretool-1.0.0.dist-info/licenses/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+tretool-1.0.0.dist-info/METADATA,sha256=QgRN5n9vyfakFhBtIkWQZ5VfX-LCxGlDKf6vr7Cfnl4,953
+tretool-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tretool-1.0.0.dist-info/top_level.txt,sha256=0kbUVnSHjYxSRD1ziCdpw73ECdl7QysxeNHlRuY9xtc,8
+tretool-1.0.0.dist-info/RECORD,,