from typing import Any, Dict, List, Tuple

def process_data(*args: int, **kwargs: str) -> List[Any]:
    """處理數(shù)據(jù)函數(shù)，要求args為整數(shù)，kwargs值為字符串"""
    results = []
    
    # 處理位置參數(shù)
    for i, arg in enumerate(args):
        if not isinstance(arg, int):
            raise TypeError(f"參數(shù) {i} 應(yīng)為整數(shù)類型，實(shí)際為 {type(arg)}")
        results.append(f"位置參數(shù) {i}: {arg}")
    
    # 處理關(guān)鍵字參數(shù)
    for key, value in kwargs.items():
        if not isinstance(value, str):
            raise TypeError(f"關(guān)鍵字參數(shù) '{key}' 應(yīng)為字符串類型，實(shí)際為 {type(value)}")
        results.append(f"關(guān)鍵字參數(shù) {key}: {value}")
    
    return results

# 正確使用
result = process_data(1, 2, 3, name="Alice", city="Beijing")
print(result)

# 錯(cuò)誤使用（會(huì)拋出TypeError）
try:
    process_data(1, "invalid", name=123)
except TypeError as e:
    print(f"類型錯(cuò)誤: {e}")

from functools import wraps
from typing import get_type_hints

def validate_args(*expected_arg_types, **expected_kwarg_types):
    """參數(shù)驗(yàn)證裝飾器工廠"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 驗(yàn)證位置參數(shù)類型
            for i, (arg, expected_type) in enumerate(zip(args, expected_arg_types)):
                if not isinstance(arg, expected_type):
                    raise TypeError(f"位置參數(shù) {i} 應(yīng)為 {expected_type.__name__} 類型")
            
            # 驗(yàn)證關(guān)鍵字參數(shù)類型
            for key, value in kwargs.items():
                if key in expected_kwarg_types:
                    expected_type = expected_kwarg_types[key]
                    if not isinstance(value, expected_type):
                        raise TypeError(f"關(guān)鍵字參數(shù) '{key}' 應(yīng)為 {expected_type.__name__} 類型")
            
            return func(*args, **kwargs)
        return wrapper
    return decorator

# 使用裝飾器強(qiáng)制參數(shù)簽名
@validate_args(int, str, str, age=int, city=str)
def create_profile(id, name, email, *, age=None, city=None):
    """創(chuàng)建用戶檔案"""
    profile = {
        'id': id,
        'name': name,
        'email': email,
        'age': age,
        'city': city
    }
    return profile

# 正確調(diào)用
profile = create_profile(1, "Alice", "alice@example.com", age=25, city="Beijing")
print(profile)

# 錯(cuò)誤調(diào)用（會(huì)拋出TypeError）
try:
    create_profile("invalid", "Alice", "alice@example.com", age="25")
except TypeError as e:
    print(f"驗(yàn)證錯(cuò)誤: {e}")

import inspect
from functools import wraps
from typing import get_type_hints, Any

def strict_signature(func):
    """嚴(yán)格參數(shù)簽名裝飾器"""
    # 獲取函數(shù)簽名和類型提示
    sig = inspect.signature(func)
    type_hints = get_type_hints(func)
    
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 綁定參數(shù)到簽名
        bound_args = sig.bind(*args, **kwargs)
        bound_args.apply_defaults()
        
        # 驗(yàn)證參數(shù)類型
        for param_name, value in bound_args.arguments.items():
            if param_name in type_hints:
                expected_type = type_hints[param_name]
                if not isinstance(value, expected_type):
                    raise TypeError(
                        f"參數(shù) '{param_name}' 應(yīng)為 {expected_type.__name__} 類型, "
                        f"實(shí)際為 {type(value).__name__}"
                    )
        
        return func(*args, **kwargs)
    
    # 更新包裝函數(shù)的簽名
    wrapper.__signature__ = sig
    return wrapper

@strict_signature
def advanced_processor(
    data: list,
    threshold: int = 10,
    *,
    algorithm: str = "default",
    verbose: bool = False
) -> dict:
    """高級(jí)數(shù)據(jù)處理函數(shù)"""
    result = {
        'processed_data': [x for x in data if x > threshold],
        'algorithm': algorithm,
        'verbose': verbose
    }
    return result

# 使用示例
try:
    result = advanced_processor([1, 5, 15, 25], threshold=5, algorithm="fast")
    print(result)
except TypeError as e:
    print(f"類型錯(cuò)誤: {e}")

# 錯(cuò)誤調(diào)用示例
try:
    advanced_processor("invalid_data", threshold=5)
except TypeError as e:
    print(f"類型錯(cuò)誤: {e}")

from pydantic import BaseModel, ValidationError, validator
from typing import Optional, List
from functools import wraps

def validate_kwargs_with_model(model_class):
    """使用Pydantic模型驗(yàn)證kwargs的裝飾器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            try:
                # 使用Pydantic模型驗(yàn)證關(guān)鍵字參數(shù)
                validated_kwargs = model_class(**kwargs)
                return func(*args, **validated_kwargs.dict())
            except ValidationError as e:
                # 轉(zhuǎn)換Pydantic驗(yàn)證錯(cuò)誤為更友好的錯(cuò)誤信息
                errors = []
                for error in e.errors():
                    field = error['loc'][0]
                    msg = error['msg']
                    errors.append(f"字段 '{field}': {msg}")
                raise ValueError(f"參數(shù)驗(yàn)證失敗: {'; '.join(errors)}")
        return wrapper
    return decorator

# 定義Pydantic模型
class ProcessingConfig(BaseModel):
    algorithm: str = "default"
    max_iterations: int = 100
    tolerance: float = 1e-6
    enabled_features: List[str] = []
    
    @validator('max_iterations')
    def validate_max_iterations(cls, v):
        if v <= 0:
            raise ValueError('必須為正數(shù)')
        if v > 10000:
            raise ValueError('不能超過10000')
        return v
    
    @validator('algorithm')
    def validate_algorithm(cls, v):
        allowed_algorithms = ['default', 'fast', 'precise']
        if v not in allowed_algorithms:
            raise ValueError(f'必須是以下值之一: {allowed_algorithms}')
        return v

@validate_kwargs_with_model(ProcessingConfig)
def process_with_config(data, **kwargs):
    """使用驗(yàn)證后的配置處理數(shù)據(jù)"""
    config = ProcessingConfig(**kwargs)
    print(f"使用算法: {config.algorithm}")
    print(f"最大迭代次數(shù): {config.max_iterations}")
    return f"處理完成: {len(data)} 條數(shù)據(jù)"

# 正確使用
result = process_with_config([1, 2, 3], algorithm="fast", max_iterations=500)
print(result)

# 錯(cuò)誤使用（會(huì)拋出驗(yàn)證錯(cuò)誤）
try:
    process_with_config([1, 2, 3], algorithm="invalid", max_iterations=-1)
except ValueError as e:
    print(f"驗(yàn)證錯(cuò)誤: {e}")

class Parameter:
    """參數(shù)描述符，定義參數(shù)的約束條件"""
    
    def __init__(self, param_type=None, default=None, validator=None, required=True):
        self.param_type = param_type
        self.default = default
        self.validator = validator
        self.required = required
        self.name = None  # 將在描述符協(xié)議中設(shè)置
    
    def __set_name__(self, owner, name):
        self.name = name
    
    def __get__(self, instance, owner):
        if instance is None:
            return self
        return instance.__dict__.get(self.name, self.default)
    
    def __set__(self, instance, value):
        if value is None and self.required:
            raise ValueError(f"參數(shù) '{self.name}' 是必需的")
        
        if value is not None and self.param_type and not isinstance(value, self.param_type):
            raise TypeError(f"參數(shù) '{self.name}' 必須為 {self.param_type.__name__} 類型")
        
        if value is not None and self.validator:
            try:
                self.validator(value)
            except ValueError as e:
                raise ValueError(f"參數(shù) '{self.name}' 驗(yàn)證失敗: {str(e)}")
        
        instance.__dict__[self.name] = value

def validated_function(**param_definitions):
    """基于參數(shù)描述符的裝飾器工廠"""
    def decorator(func):
        # 創(chuàng)建新類來保存參數(shù)描述符
        class ValidatedFunction:
            def __init__(self):
                for name, param in param_definitions.items():
                    setattr(self.__class__, name, param)
            
            def __call__(self, *args, **kwargs):
                # 創(chuàng)建驗(yàn)證實(shí)例
                validator_instance = self.__class__()
                
                # 應(yīng)用參數(shù)值
                sig = inspect.signature(func)
                bound_args = sig.bind(*args, **kwargs)
                
                for name, value in bound_args.arguments.items():
                    if name in param_definitions:
                        setattr(validator_instance, name, value)
                
                # 調(diào)用原函數(shù)
                return func(*args, **kwargs)
        
        return ValidatedFunction()
    return decorator

# 使用自定義驗(yàn)證系統(tǒng)
def validate_positive(value):
    if value <= 0:
        raise ValueError("必須為正數(shù)")

@validated_function(
    threshold=Parameter(int, default=10, validator=validate_positive),
    algorithm=Parameter(str, default="default"),
    max_workers=Parameter(int, default=1, validator=validate_positive)
)
def parallel_processing(data, threshold, algorithm, max_workers):
    """并行數(shù)據(jù)處理函數(shù)"""
    print(f"閾值: {threshold}, 算法: {algorithm}, 工作線程: {max_workers}")
    return f"處理了 {len(data)} 條數(shù)據(jù)"

# 使用示例
result = parallel_processing([1, 2, 3], threshold=5, algorithm="fast", max_workers=4)
print(result)

class ValidatorChain:
    """鏈?zhǔn)津?yàn)證器，支持多個(gè)驗(yàn)證規(guī)則"""
    
    def __init__(self):
        self.validators = []
    
    def add_type(self, expected_type):
        """添加類型驗(yàn)證"""
        def type_validator(value):
            if not isinstance(value, expected_type):
                raise TypeError(f"應(yīng)為 {expected_type.__name__} 類型")
        self.validators.append(type_validator)
        return self
    
    def add_range(self, min_value=None, max_value=None):
        """添加范圍驗(yàn)證"""
        def range_validator(value):
            if min_value is not None and value < min_value:
                raise ValueError(f"不能小于 {min_value}")
            if max_value is not None and value > max_value:
                raise ValueError(f"不能大于 {max_value}")
        self.validators.append(range_validator)
        return self
    
    def add_custom(self, validator_func, message=None):
        """添加自定義驗(yàn)證"""
        def custom_validator(value):
            try:
                validator_func(value)
            except Exception as e:
                raise ValueError(message or f"自定義驗(yàn)證失敗: {str(e)}")
        self.validators.append(custom_validator)
        return self
    
    def validate(self, value):
        """執(zhí)行所有驗(yàn)證"""
        for validator in self.validators:
            validator(value)
        return value

def with_validation(**param_validators):
    """鏈?zhǔn)津?yàn)證裝飾器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            sig = inspect.signature(func)
            bound_args = sig.bind(*args, **kwargs)
            
            for param_name, value in bound_args.arguments.items():
                if param_name in param_validators:
                    try:
                        # 執(zhí)行鏈?zhǔn)津?yàn)證
                        param_validators[param_name].validate(value)
                    except (TypeError, ValueError) as e:
                        raise ValueError(f"參數(shù) '{param_name}' 驗(yàn)證失敗: {str(e)}")
            
            return func(*args, **kwargs)
        return wrapper
    return decorator

# 創(chuàng)建驗(yàn)證器鏈
threshold_validator = (ValidatorChain()
                      .add_type(int)
                      .add_range(min_value=0, max_value=1000))

algorithm_validator = (ValidatorChain()
                      .add_type(str)
                      .add_custom(lambda x: x in ['default', 'fast', 'precise'], 
                                 "必須是 'default', 'fast' 或 'precise'"))

@with_validation(
    threshold=threshold_validator,
    algorithm=algorithm_validator
)
def validated_processing(data, threshold=10, algorithm="default"):
    """經(jīng)過驗(yàn)證的數(shù)據(jù)處理函數(shù)"""
    return f"使用算法 {algorithm} 處理數(shù)據(jù)，閾值: {threshold}"

# 使用示例
try:
    result = validated_processing([1, 2, 3], threshold=50, algorithm="fast")
    print(result)
except ValueError as e:
    print(f"驗(yàn)證錯(cuò)誤: {e}")

# 錯(cuò)誤示例
try:
    validated_processing([1, 2, 3], threshold=1500, algorithm="invalid")
except ValueError as e:
    print(f"驗(yàn)證錯(cuò)誤: {e}")

from flask import Flask, request, jsonify
from functools import wraps

app = Flask(__name__)

def validate_api_params(**expected_params):
    """API參數(shù)驗(yàn)證裝飾器"""
    def decorator(route_func):
        @wraps(route_func)
        def wrapper(*args, **kwargs):
            errors = []
            
            # 驗(yàn)證查詢參數(shù)
            for param_name, param_type in expected_params.items():
                if param_name in request.args:
                    try:
                        # 轉(zhuǎn)換參數(shù)類型
                        converted_value = param_type(request.args[param_name])
                        kwargs[param_name] = converted_value
                    except (ValueError, TypeError):
                        errors.append(f"參數(shù) '{param_name}' 類型無效")
                elif param_name in expected_params:
                    errors.append(f"缺少必需參數(shù): {param_name}")
            
            if errors:
                return jsonify({"error": "參數(shù)驗(yàn)證失敗", "details": errors}), 400
            
            return route_func(*args, **kwargs)
        return wrapper
    return decorator

@app.route('/api/users')
@validate_api_params(page=int, per_page=int, search=str)
def get_users(page=1, per_page=10, search=None):
    """獲取用戶列表API"""
    users = [
        {"id": 1, "name": "Alice", "email": "alice@example.com"},
        {"id": 2, "name": "Bob", "email": "bob@example.com"}
    ]
    
    # 模擬過濾和分頁
    if search:
        users = [u for u in users if search.lower() in u['name'].lower()]
    
    start = (page - 1) * per_page
    end = start + per_page
    paginated_users = users[start:end]
    
    return jsonify({
        "page": page,
        "per_page": per_page,
        "total": len(users),
        "users": paginated_users
    })

if __name__ == '__main__':
    app.run(debug=True)

from functools import wraps
from typing import List, Dict, Any
import pandas as pd

def validate_dataframe_params(**param_rules):
    """DataFrame參數(shù)驗(yàn)證裝飾器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            # 提取DataFrame參數(shù)
            dataframe_args = {}
            for i, arg in enumerate(args):
                if isinstance(arg, pd.DataFrame):
                    dataframe_args[f'arg_{i}'] = arg
            
            for key, value in kwargs.items():
                if isinstance(value, pd.DataFrame):
                    dataframe_args[key] = value
            
            # 驗(yàn)證DataFrame參數(shù)
            for df_name, dataframe in dataframe_args.items():
                if df_name in param_rules:
                    rules = param_rules[df_name]
                    
                    # 驗(yàn)證必需列
                    if 'required_columns' in rules:
                        missing_columns = [
                            col for col in rules['required_columns'] 
                            if col not in dataframe.columns
                        ]
                        if missing_columns:
                            raise ValueError(f"DataFrame '{df_name}' 缺少必需列: {missing_columns}")
                    
                    # 驗(yàn)證數(shù)據(jù)類型
                    if 'dtype_checks' in rules:
                        for column, expected_dtype in rules['dtype_checks'].items():
                            if column in dataframe.columns:
                                actual_dtype = dataframe[column].dtype
                                if not pd.api.types.is_dtype(actual_dtype, expected_dtype):
                                    raise TypeError(
                                        f"列 '{column}' 應(yīng)為 {expected_dtype} 類型, "
                                        f"實(shí)際為 {actual_dtype}"
                                    )
            
            return func(*args, **kwargs)
        return wrapper
    return decorator

@validate_dataframe_params(
    data={
        'required_columns': ['id', 'value', 'timestamp'],
        'dtype_checks': {'id': 'int64', 'value': 'float64'}
    },
    metadata={
        'required_columns': ['dataset_name', 'version']
    }
)
def process_data_pipeline(data, metadata, method='average', window_size=5):
    """數(shù)據(jù)處理管道"""
    print(f"處理數(shù)據(jù)，形狀: {data.shape}")
    print(f"使用方法: {method}, 窗口大小: {window_size}")
    
    # 模擬數(shù)據(jù)處理
    if method == 'average':
        result = data['value'].rolling(window=window_size).mean()
    else:
        result = data['value']
    
    return result

# 使用示例
try:
    sample_data = pd.DataFrame({
        'id': [1, 2, 3, 4, 5],
        'value': [10.5, 20.3, 15.7, 25.1, 18.9],
        'timestamp': pd.date_range('2023-01-01', periods=5)
    })
    
    sample_metadata = pd.DataFrame({
        'dataset_name': ['test_dataset'],
        'version': [1.0]
    })
    
    result = process_data_pipeline(sample_data, sample_metadata, method='average')
    print("處理成功")
except (ValueError, TypeError) as e:
    print(f"處理失敗: {e}")