File size: 9,330 Bytes
6aecb2e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
"""
验证工具 - 验证输入参数和配置
"""

import os
import re
from typing import Optional, List, Dict, Any
from pathlib import Path
from urllib.parse import urlparse
import logging

logger = logging.getLogger(__name__)


def validate_file_path(file_path: str, check_exists: bool = True) -> bool:
    """
    验证文件路径
    
    Args:
        file_path: 文件路径
        check_exists: 是否检查文件存在
        
    Returns:
        是否有效
    """
    if not file_path or not isinstance(file_path, str):
        return False
    
    try:
        path = Path(file_path)
        
        # 检查路径格式
        if not path.is_absolute() and not path.exists():
            # 尝试相对路径
            path = Path.cwd() / path
        
        if check_exists:
            return path.exists() and path.is_file()
        else:
            # 检查父目录是否存在(用于输出文件)
            return path.parent.exists() or path.parent == Path.cwd()
    
    except Exception as e:
        logger.debug(f"文件路径验证失败: {e}")
        return False


def validate_url(url: str) -> bool:
    """
    验证URL格式
    
    Args:
        url: URL字符串
        
    Returns:
        是否为有效URL
    """
    if not url or not isinstance(url, str):
        return False
    
    try:
        result = urlparse(url)
        return all([
            result.scheme in ['http', 'https'],
            result.netloc,
            len(url) < 2048  # URL长度限制
        ])
    except Exception:
        return False


def validate_config(config: Dict[str, Any]) -> List[str]:
    """
    验证配置参数
    
    Args:
        config: 配置字典
        
    Returns:
        错误信息列表,空列表表示验证通过
    """
    errors = []
    
    # 验证LLM配置
    llm_model = config.get('llm_model')
    if not llm_model or not isinstance(llm_model, str):
        errors.append("llm_model 必须是非空字符串")
    
    llm_provider = config.get('llm_provider')
    valid_providers = ['openai', 'anthropic', 'azure']
    if llm_provider not in valid_providers:
        errors.append(f"llm_provider 必须是以下之一: {valid_providers}")
    
    # 验证数值参数
    numeric_params = {
        'max_slides': (1, 100),
        'chunk_size': (100, 9999999),
        'chunk_overlap': (0, 1000),
        'max_tokens': (100, 9999999),
    }
    
    for param, (min_val, max_val) in numeric_params.items():
        value = config.get(param)
        if value is not None:
            if not isinstance(value, (int, float)):
                errors.append(f"{param} 必须是数字")
            elif not (min_val <= value <= max_val):
                errors.append(f"{param} 必须在 {min_val} 到 {max_val} 之间")
    
    # 验证温度参数
    temperature = config.get('temperature')
    if temperature is not None:
        if not isinstance(temperature, (int, float)):
            errors.append("temperature 必须是数字")
        elif not (0.0 <= temperature <= 2.0):
            errors.append("temperature 必须在 0.0 到 2.0 之间")

    # 验证base_url
    base_url = config.get('openai_base_url')
    if base_url and not validate_url(base_url):
        errors.append("openai_base_url 必须是有效的URL")
    
    # 验证分块策略
    chunk_strategy = config.get('chunk_strategy')
    valid_strategies = ['paragraph', 'semantic', 'recursive', 'hybrid', 'fast']
    if chunk_strategy and chunk_strategy not in valid_strategies:
        errors.append(f"chunk_strategy 必须是以下之一: {valid_strategies}")
    
    # 验证日志级别
    log_level = config.get('log_level')
    valid_levels = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
    if log_level and log_level.upper() not in valid_levels:
        errors.append(f"log_level 必须是以下之一: {valid_levels}")
    
    return errors


def validate_api_key(api_key: str, provider: str) -> bool:
    """
    验证API密钥格式
    
    Args:
        api_key: API密钥
        provider: 提供商名称
        
    Returns:
        是否有效
    """
    if not api_key or not isinstance(api_key, str):
        return False
    
    # 基本长度检查
    if len(api_key) < 10:
        return False
    
    # 提供商特定的验证
    if provider == 'openai':
        # OpenAI API密钥通常以sk-开头
        return api_key.startswith('sk-') and len(api_key) > 40
    elif provider == 'anthropic':
        # Anthropic API密钥通常以sk-ant-开头
        return api_key.startswith('sk-ant-') and len(api_key) > 50
    elif provider == 'azure':
        # Azure密钥格式较为灵活
        return len(api_key) >= 32
    
    return True  # 其他提供商的基本验证


def validate_slide_data(slide_data: Dict[str, Any]) -> List[str]:
    """
    验证幻灯片数据
    
    Args:
        slide_data: 幻灯片数据字典
        
    Returns:
        错误信息列表
    """
    errors = []
    
    # 必需字段
    required_fields = ['page_number', 'title', 'content_points', 'slide_type']
    for field in required_fields:
        if field not in slide_data:
            errors.append(f"缺少必需字段: {field}")
    
    # 验证页码
    page_number = slide_data.get('page_number')
    if page_number is not None:
        if not isinstance(page_number, int) or page_number < 1:
            errors.append("page_number 必须是正整数")
    
    # 验证标题
    title = slide_data.get('title')
    if title is not None:
        if not isinstance(title, str) or not title.strip():
            errors.append("title 必须是非空字符串")
        elif len(title) > 200:
            errors.append("title 长度不能超过200字符")
    
    # 验证内容要点
    content_points = slide_data.get('content_points')
    if content_points is not None:
        if not isinstance(content_points, list):
            errors.append("content_points 必须是列表")
        else:
            for i, point in enumerate(content_points):
                if not isinstance(point, str):
                    errors.append(f"content_points[{i}] 必须是字符串")
                elif len(point) > 500:
                    errors.append(f"content_points[{i}] 长度不能超过500字符")
    
    # 验证幻灯片类型
    slide_type = slide_data.get('slide_type')
    valid_types = ['title', 'content', 'conclusion']
    if slide_type and slide_type not in valid_types:
        errors.append(f"slide_type 必须是以下之一: {valid_types}")
    
    return errors


def validate_ppt_outline(outline_data: Dict[str, Any]) -> List[str]:
    """
    验证PPT大纲数据
    
    Args:
        outline_data: PPT大纲数据
        
    Returns:
        错误信息列表
    """
    errors = []
    
    # 验证基本字段
    if 'title' not in outline_data:
        errors.append("缺少PPT标题")
    elif not isinstance(outline_data['title'], str) or not outline_data['title'].strip():
        errors.append("PPT标题必须是非空字符串")
    
    if 'slides' not in outline_data:
        errors.append("缺少幻灯片列表")
    elif not isinstance(outline_data['slides'], list):
        errors.append("slides 必须是列表")
    else:
        # 验证每个幻灯片
        slides = outline_data['slides']
        if not slides:
            errors.append("幻灯片列表不能为空")
        
        page_numbers = set()
        for i, slide in enumerate(slides):
            slide_errors = validate_slide_data(slide)
            for error in slide_errors:
                errors.append(f"幻灯片 {i+1}: {error}")
            
            # 检查页码重复
            page_num = slide.get('page_number')
            if page_num in page_numbers:
                errors.append(f"页码重复: {page_num}")
            else:
                page_numbers.add(page_num)
    
    # 验证总页数
    total_pages = outline_data.get('total_pages')
    if total_pages is not None:
        if not isinstance(total_pages, int) or total_pages < 1:
            errors.append("total_pages 必须是正整数")
        elif 'slides' in outline_data and len(outline_data['slides']) != total_pages:
            errors.append("total_pages 与实际幻灯片数量不匹配")
    
    return errors


def sanitize_filename(filename: str) -> str:
    """
    清理文件名,移除非法字符
    
    Args:
        filename: 原始文件名
        
    Returns:
        清理后的文件名
    """
    # 移除或替换非法字符
    illegal_chars = r'[<>:"/\\|?*]'
    sanitized = re.sub(illegal_chars, '_', filename)
    
    # 移除多余的空格和点
    sanitized = re.sub(r'\s+', ' ', sanitized).strip()
    sanitized = sanitized.strip('.')
    
    # 确保不为空
    if not sanitized:
        sanitized = "untitled"
    
    # 限制长度
    if len(sanitized) > 200:
        sanitized = sanitized[:200]
    
    return sanitized


def validate_encoding(encoding: str) -> bool:
    """
    验证编码名称
    
    Args:
        encoding: 编码名称
        
    Returns:
        是否为有效编码
    """
    try:
        import codecs
        codecs.lookup(encoding)
        return True
    except (LookupError, TypeError):
        return False