# 傳統(tǒng)的requirements.txt文件示例
# 這種格式缺乏嚴格的版本鎖定，容易導致依賴沖突
Django>=3.2,<4.0
requests==2.25.1
numpy>=1.19.0
pandas

# 安裝Pipenv
pip install pipenv

# 創(chuàng)建新項目
mkdir my-project && cd my-project

# 初始化虛擬環(huán)境（自動創(chuàng)建）
pipenv install

# 安裝生產依賴
pipenv install django==4.0.0

# 安裝開發(fā)依賴
pipenv install --dev pytest

# 激活虛擬環(huán)境
pipenv shell

# 運行命令而不激活環(huán)境
pipenv run python manage.py runserver

# Pipfile 示例
[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]
django = "==4.0.0"
requests = "*"
numpy = { version = ">=1.21.0", markers = "python_version >= '3.8'" }

[dev-packages]
pytest = ">=6.0.0"
black = "*"

[requires]
python_version = "3.9"

#!/usr/bin/env python3
"""
Pipenv項目示例：簡單的Web API

這個示例展示如何使用Pipenv管理一個Flask Web API項目的依賴
"""

import os
import sys

def setup_pipenv_project(project_name="flask-api-project"):
    """設置一個使用Pipenv的Flask項目"""
    
    # 創(chuàng)建項目目錄
    os.makedirs(project_name, exist_ok=True)
    os.chdir(project_name)
    
    # Pipfile內容
    pipfile_content = '''[[source]]
url = "https://pypi.org/simple"
verify_ssl = true
name = "pypi"

[packages]
flask = "==2.3.3"
flask-restx = "==1.1.0"
python-dotenv = "==1.0.0"
requests = "==2.31.0"
sqlalchemy = "==2.0.23"

[dev-packages]
pytest = "==7.4.3"
pytest-flask = "==1.2.0"
black = "==23.9.1"
flake8 = "==6.1.0"

[requires]
python_version = "3.9"
'''
    
    # 創(chuàng)建Pipfile
    with open('Pipfile', 'w') as f:
        f.write(pipfile_content)
    
    print(f"創(chuàng)建項目 {project_name}")
    print("Pipfile 已生成")
    
    # 示例應用代碼
    app_code = '''from flask import Flask, jsonify
from flask_restx import Api, Resource, fields
import os

app = Flask(__name__)
api = Api(app, version='1.0', title='Sample API',
          description='A sample API with Pipenv')

# 命名空間
ns = api.namespace('items', description='Item operations')

# 數(shù)據(jù)模型
item_model = api.model('Item', {
    'id': fields.Integer(readonly=True, description='Item identifier'),
    'name': fields.String(required=True, description='Item name'),
    'description': fields.String(description='Item description')
})

# 模擬數(shù)據(jù)
items = [
    {'id': 1, 'name': 'Item 1', 'description': 'First item'},
    {'id': 2, 'name': 'Item 2', 'description': 'Second item'}
]

@ns.route('/')
class ItemList(Resource):
    @ns.marshal_list_with(item_model)
    def get(self):
        """返回所有項目"""
        return items

@ns.route('/<int:id>')
@ns.response(404, 'Item not found')
@ns.param('id', 'Item identifier')
class Item(Resource):
    @ns.marshal_with(item_model)
    def get(self, id):
        """根據(jù)ID返回項目"""
        for item in items:
            if item['id'] == id:
                return item
        api.abort(404, f"Item {id} not found")

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)
'''
    
    # 創(chuàng)建應用文件
    with open('app.py', 'w') as f:
        f.write(app_code)
    
    # 測試文件
    test_code = '''import pytest
from app import app

@pytest.fixture
def client():
    app.config['TESTING'] = True
    with app.test_client() as client:
        yield client

def test_get_items(client):
    """測試獲取所有項目"""
    response = client.get('/items/')
    assert response.status_code == 200
    data = response.get_json()
    assert len(data) == 2
    assert data[0]['name'] == 'Item 1'

def test_get_item(client):
    """測試獲取單個項目"""
    response = client.get('/items/1')
    assert response.status_code == 200
    data = response.get_json()
    assert data['name'] == 'Item 1'

def test_get_nonexistent_item(client):
    """測試獲取不存在的項目"""
    response = client.get('/items/999')
    assert response.status_code == 404
'''
    
    # 創(chuàng)建測試文件
    with open('test_app.py', 'w') as f:
        f.write(test_code)
    
    # 環(huán)境變量文件
    with open('.env', 'w') as f:
        f.write('FLASK_ENV=development\n')
        f.write('SECRET_KEY=your-secret-key-here\n')
    
    print("項目文件已創(chuàng)建")
    print("\n下一步:")
    print("1. 運行: pipenv install")
    print("2. 運行: pipenv shell")
    print("3. 運行: python app.py")
    print("4. 在另一個終端運行: pipenv run pytest")

if __name__ == "__main__":
    if len(sys.argv) > 1:
        setup_pipenv_project(sys.argv[1])
    else:
        setup_pipenv_project()

# 檢查依賴中的安全漏洞
pipenv check

# 更新有安全問題的依賴
pipenv update --outdated
pipenv update package-name

# 顯示依賴圖
pipenv graph

# 顯示項目信息
pipenv --where    # 項目路徑
pipenv --venv     # 虛擬環(huán)境路徑
pipenv --py       # Python解釋器路徑

# 清理未使用的包
pipenv clean

# 生成鎖定文件
pipenv lock

# 在生產環(huán)境安裝（使用鎖定文件）
pipenv install --deploy

# 忽略Pipfile，只使用Pipfile.lock
pipenv install --ignore-pipfile

# 安裝Poetry
curl -sSL https://install.python-poetry.org | python3 -

# 創(chuàng)建新項目
poetry new my-project
cd my-project

# 初始化現(xiàn)有項目
poetry init

# 添加依賴
poetry add django@^4.0.0

# 添加開發(fā)依賴
poetry add --dev pytest

# 安裝所有依賴
poetry install

# 運行命令
poetry run python manage.py runserver

# 激活虛擬環(huán)境
poetry shell

# pyproject.toml 示例
[tool.poetry]
name = "my-project"
version = "0.1.0"
description = "A sample Python project"
authors = ["Your Name <you@example.com>"]
readme = "README.md"
packages = [{include = "my_project"}]

[tool.poetry.dependencies]
python = "^3.8"
django = "^4.0.0"
requests = "^2.25.0"

[tool.poetry.group.dev.dependencies]
pytest = "^7.0.0"
black = "^23.0.0"

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

#!/usr/bin/env python3
"""
Poetry項目示例：數(shù)據(jù)處理的Python包

這個示例展示如何使用Poetry管理一個數(shù)據(jù)處理包的依賴和發(fā)布
"""

import os
import sys
import shutil

def setup_poetry_project(project_name="data-processor"):
    """設置一個使用Poetry的數(shù)據(jù)處理項目"""
    
    # 如果目錄已存在，先清理
    if os.path.exists(project_name):
        shutil.rmtree(project_name)
    
    # 使用Poetry創(chuàng)建新項目
    os.system(f"poetry new {project_name}")
    os.chdir(project_name)
    
    # 修改pyproject.toml
    pyproject_content = '''[tool.poetry]
name = "data-processor"
version = "0.1.0"
description = "A powerful data processing library"
authors = ["Data Scientist <data@example.com>"]
readme = "README.md"
packages = [{include = "data_processor"}]
license = "MIT"

[tool.poetry.dependencies]
python = "^3.8"
pandas = "^2.0.0"
numpy = "^1.24.0"
requests = "^2.31.0"
click = "^8.1.0"
python-dotenv = "^1.0.0"

[tool.poetry.group.dev.dependencies]
pytest = "^7.4.0"
pytest-cov = "^4.1.0"
black = "^23.0.0"
flake8 = "^6.0.0"
mypy = "^1.5.0"
jupyter = "^1.0.0"

[tool.poetry.scripts]
process-data = "data_processor.cli:main"

[build-system]
requires = ["poetry-core>=1.0.0"]
build-backend = "poetry.core.masonry.api"

[tool.black]
line-length = 88
target-version = ['py38']
'''
    
    # 更新pyproject.toml
    with open('pyproject.toml', 'w') as f:
        f.write(pyproject_content)
    
    print(f"創(chuàng)建項目 {project_name}")
    
    # 創(chuàng)建包目錄結構
    os.makedirs('data_processor', exist_ok=True)
    
    # 創(chuàng)建__init__.py
    with open('data_processor/__init__.py', 'w') as f:
        f.write('''"""
Data Processor - A powerful data processing library.

This package provides utilities for data loading, transformation,
and analysis with support for multiple data sources.
"""

__version__ = "0.1.0"
__author__ = "Data Scientist <data@example.com>"

from data_processor.core import DataProcessor
from data_processor.loaders import CSVLoader, JSONLoader
from data_processor.transformers import Cleaner, Transformer

__all__ = [
    "DataProcessor",
    "CSVLoader", 
    "JSONLoader",
    "Cleaner",
    "Transformer",
]
''')
    
    # 創(chuàng)建核心模塊
    core_code = '''import pandas as pd
from typing import Union, List, Dict, Any
import logging

logger = logging.getLogger(__name__)

class DataProcessor:
    """
    數(shù)據(jù)處理器的核心類
    
    提供數(shù)據(jù)加載、轉換和分析的統(tǒng)一接口
    """
    
    def __init__(self):
        self.data = None
        self.transformations = []
        logger.info("DataProcessor initialized")
    
    def load_data(self, data: Union[str, pd.DataFrame], **kwargs) -> 'DataProcessor':
        """
        加載數(shù)據(jù)
        
        Args:
            data: 文件路徑或DataFrame
            **kwargs: 傳遞給加載器的額外參數(shù)
            
        Returns:
            self: 支持鏈式調用
        """
        if isinstance(data, str):
            if data.endswith('.csv'):
                from .loaders import CSVLoader
                loader = CSVLoader()
            elif data.endswith('.json'):
                from .loaders import JSONLoader
                loader = JSONLoader()
            else:
                raise ValueError(f"Unsupported file format: {data}")
            
            self.data = loader.load(data, **kwargs)
        elif isinstance(data, pd.DataFrame):
            self.data = data.copy()
        else:
            raise TypeError("data must be a file path or DataFrame")
        
        logger.info(f"Loaded data with shape: {self.data.shape}")
        return self
    
    def clean(self, **kwargs) -> 'DataProcessor':
        """
        數(shù)據(jù)清洗
        
        Args:
            **kwargs: 清洗參數(shù)
            
        Returns:
            self: 支持鏈式調用
        """
        from .transformers import Cleaner
        cleaner = Cleaner(**kwargs)
        self.data = cleaner.transform(self.data)
        self.transformations.append(('clean', kwargs))
        logger.info("Data cleaned")
        return self
    
    def transform(self, operations: List[Dict[str, Any]]) -> 'DataProcessor':
        """
        數(shù)據(jù)轉換
        
        Args:
            operations: 轉換操作列表
            
        Returns:
            self: 支持鏈式調用
        """
        from .transformers import Transformer
        transformer = Transformer()
        self.data = transformer.transform(self.data, operations)
        self.transformations.append(('transform', operations))
        logger.info(f"Applied {len(operations)} transformations")
        return self
    
    def analyze(self) -> Dict[str, Any]:
        """
        數(shù)據(jù)分析
        
        Returns:
            Dict: 分析結果
        """
        if self.data is None:
            raise ValueError("No data loaded. Call load_data() first.")
        
        analysis = {
            'shape': self.data.shape,
            'columns': list(self.data.columns),
            'dtypes': self.data.dtypes.to_dict(),
            'null_counts': self.data.isnull().sum().to_dict(),
            'memory_usage': self.data.memory_usage(deep=True).sum(),
        }
        
        # 數(shù)值列的統(tǒng)計信息
        numeric_cols = self.data.select_dtypes(include=['number']).columns
        if len(numeric_cols) > 0:
            analysis['numeric_stats'] = self.data[numeric_cols].describe().to_dict()
        
        logger.info("Analysis completed")
        return analysis
    
    def save(self, path: str, **kwargs) -> None:
        """
        保存數(shù)據(jù)
        
        Args:
            path: 保存路徑
            **kwargs: 保存參數(shù)
        """
        if self.data is None:
            raise ValueError("No data to save")
        
        if path.endswith('.csv'):
            self.data.to_csv(path, **kwargs)
        elif path.endswith('.json'):
            self.data.to_json(path, **kwargs)
        else:
            raise ValueError(f"Unsupported output format: {path}")
        
        logger.info(f"Data saved to: {path}")
    
    def get_data(self) -> pd.DataFrame:
        """獲取處理后的數(shù)據(jù)"""
        return self.data.copy() if self.data is not None else None
'''
    
    with open('data_processor/core.py', 'w') as f:
        f.write(core_code)
    
    # 創(chuàng)建數(shù)據(jù)加載器模塊
    loaders_dir = os.path.join('data_processor', 'loaders')
    os.makedirs(loaders_dir, exist_ok=True)
    
    with open(os.path.join(loaders_dir, '__init__.py'), 'w') as f:
        f.write('''"""
數(shù)據(jù)加載器模塊

提供多種數(shù)據(jù)格式的加載功能
"""

from .csv_loader import CSVLoader
from .json_loader import JSONLoader

__all__ = ["CSVLoader", "JSONLoader"]
''')
    
    with open(os.path.join(loaders_dir, 'base_loader.py'), 'w') as f:
        f.write('''from abc import ABC, abstractmethod
import pandas as pd
from typing import Any, Dict

class BaseLoader(ABC):
    """數(shù)據(jù)加載器基類"""
    
    @abstractmethod
    def load(self, path: str, **kwargs) -> pd.DataFrame:
        """加載數(shù)據(jù)"""
        pass
    
    def validate(self, data: pd.DataFrame) -> bool:
        """驗證數(shù)據(jù)"""
        return not data.empty and len(data) > 0
''')
    
    with open(os.path.join(loaders_dir, 'csv_loader.py'), 'w') as f:
        f.write('''import pandas as pd
from typing import Any, Dict
from .base_loader import BaseLoader
import logging

logger = logging.getLogger(__name__)

class CSVLoader(BaseLoader):
    """CSV文件加載器"""
    
    def load(self, path: str, **kwargs) -> pd.DataFrame:
        \"\"\"
        加載CSV文件
        
        Args:
            path: 文件路徑
            **kwargs: 傳遞給pandas.read_csv的參數(shù)
            
        Returns:
            pd.DataFrame: 加載的數(shù)據(jù)
        \"\"\"
        default_kwargs = {
            'encoding': 'utf-8',
            'na_values': ['', 'NULL', 'null', 'NaN', 'nan'],
        }
        default_kwargs.update(kwargs)
        
        try:
            data = pd.read_csv(path, **default_kwargs)
            logger.info(f"Successfully loaded CSV from {path}")
            
            if self.validate(data):
                return data
            else:
                raise ValueError("Loaded data is empty or invalid")
                
        except Exception as e:
            logger.error(f"Failed to load CSV from {path}: {e}")
            raise
''')
    
    with open(os.path.join(loaders_dir, 'json_loader.py'), 'w') as f:
        f.write('''import pandas as pd
import json
from typing import Any, Dict
from .base_loader import BaseLoader
import logging

logger = logging.getLogger(__name__)

class JSONLoader(BaseLoader):
    """JSON文件加載器"""
    
    def load(self, path: str, **kwargs) -> pd.DataFrame:
        \"\"\"
        加載JSON文件
        
        Args:
            path: 文件路徑
            **kwargs: 傳遞給pandas.read_json的參數(shù)
            
        Returns:
            pd.DataFrame: 加載的數(shù)據(jù)
        \"\"\"
        default_kwargs = {
            'orient': 'records',
            'encoding': 'utf-8',
        }
        default_kwargs.update(kwargs)
        
        try:
            # 首先嘗試pandas的read_json
            try:
                data = pd.read_json(path, **default_kwargs)
            except:
                # 如果失敗，嘗試手動加載
                with open(path, 'r', encoding='utf-8') as f:
                    json_data = json.load(f)
                data = pd.json_normalize(json_data)
            
            logger.info(f"Successfully loaded JSON from {path}")
            
            if self.validate(data):
                return data
            else:
                raise ValueError("Loaded data is empty or invalid")
                
        except Exception as e:
            logger.error(f"Failed to load JSON from {path}: {e}")
            raise
''')
    
    # 創(chuàng)建轉換器模塊
    transformers_dir = os.path.join('data_processor', 'transformers')
    os.makedirs(transformers_dir, exist_ok=True)
    
    with open(os.path.join(transformers_dir, '__init__.py'), 'w') as f:
        f.write('''"""
數(shù)據(jù)轉換器模塊

提供數(shù)據(jù)清洗和轉換功能
"""

from .cleaner import Cleaner
from .transformer import Transformer

__all__ = ["Cleaner", "Transformer"]
''')
    
    with open(os.path.join(transformers_dir, 'cleaner.py'), 'w') as f:
        f.write('''import pandas as pd
import numpy as np
from typing import Dict, Any, List
import logging

logger = logging.getLogger(__name__)

class Cleaner:
    \"\"\"數(shù)據(jù)清洗器\"\"\"
    
    def __init__(self, **kwargs):
        self.config = kwargs
    
    def transform(self, data: pd.DataFrame) -> pd.DataFrame:
        \"\"\"
        清洗數(shù)據(jù)
        
        Args:
            data: 輸入數(shù)據(jù)
            
        Returns:
            pd.DataFrame: 清洗后的數(shù)據(jù)
        \"\"\"
        if data is None:
            raise ValueError("No data to clean")
        
        # 創(chuàng)建副本以避免修改原始數(shù)據(jù)
        cleaned_data = data.copy()
        
        # 處理缺失值
        cleaned_data = self._handle_missing_values(cleaned_data)
        
        # 處理重復值
        cleaned_data = self._handle_duplicates(cleaned_data)
        
        # 數(shù)據(jù)類型轉換
        cleaned_data = self._convert_dtypes(cleaned_data)
        
        logger.info("Data cleaning completed")
        return cleaned_data
    
    def _handle_missing_values(self, data: pd.DataFrame) -> pd.DataFrame:
        \"\"\"處理缺失值\"\"\"
        strategy = self.config.get('missing_strategy', 'drop')
        
        if strategy == 'drop':
            # 刪除包含缺失值的行
            data = data.dropna()
        elif strategy == 'fill':
            # 填充缺失值
            fill_values = self.config.get('fill_values', {})
            data = data.fillna(fill_values)
        elif strategy == 'interpolate':
            # 插值
            data = data.interpolate()
        
        return data
    
    def _handle_duplicates(self, data: pd.DataFrame) -> pd.DataFrame:
        \"\"\"處理重復值\"\"\"
        keep_duplicates = self.config.get('keep_duplicates', False)
        
        if not keep_duplicates:
            subset = self.config.get('duplicate_subset', None)
            data = data.drop_duplicates(subset=subset, keep='first')
        
        return data
    
    def _convert_dtypes(self, data: pd.DataFrame) -> pd.DataFrame:
        \"\"\"轉換數(shù)據(jù)類型\"\"\"
        dtype_mapping = self.config.get('dtype_mapping', {})
        
        for col, dtype in dtype_mapping.items():
            if col in data.columns:
                try:
                    data[col] = data[col].astype(dtype)
                except Exception as e:
                    logger.warning(f"Failed to convert {col} to {dtype}: {e}")
        
        return data
''')
    
    with open(os.path.join(transformers_dir, 'transformer.py', 'w')) as f:
        f.write('''import pandas as pd
import numpy as np
from typing import Dict, Any, List, Callable
import logging

logger = logging.getLogger(__name__)

class Transformer:
    \"\"\"數(shù)據(jù)轉換器\"\"\"
    
    def transform(self, data: pd.DataFrame, operations: List[Dict[str, Any]]) -> pd.DataFrame:
        \"\"\"
        應用一系列轉換操作
        
        Args:
            data: 輸入數(shù)據(jù)
            operations: 轉換操作列表
            
        Returns:
            pd.DataFrame: 轉換后的數(shù)據(jù)
        \"\"\"
        if data is None:
            raise ValueError("No data to transform")
        
        transformed_data = data.copy()
        
        for i, operation in enumerate(operations):
            try:
                op_type = operation.get('type')
                params = operation.get('params', {})
                
                if op_type == 'rename_columns':
                    transformed_data = self._rename_columns(transformed_data, params)
                elif op_type == 'filter_rows':
                    transformed_data = self._filter_rows(transformed_data, params)
                elif op_type == 'create_column':
                    transformed_data = self._create_column(transformed_data, params)
                elif op_type == 'drop_columns':
                    transformed_data = self._drop_columns(transformed_data, params)
                elif op_type == 'aggregate':
                    transformed_data = self._aggregate(transformed_data, params)
                else:
                    logger.warning(f"Unknown operation type: {op_type}")
                
                logger.info(f"Applied transformation {i+1}: {op_type}")
                
            except Exception as e:
                logger.error(f"Failed to apply transformation {i+1}: {e}")
                raise
        
        return transformed_data
    
    def _rename_columns(self, data: pd.DataFrame, params: Dict[str, Any]) -> pd.DataFrame:
        \"\"\"重命名列\(zhòng)"\"\"
        mapping = params.get('mapping', {})
        return data.rename(columns=mapping)
    
    def _filter_rows(self, data: pd.DataFrame, params: Dict[str, Any]) -> pd.DataFrame:
        \"\"\"過濾行\(zhòng)"\"\"
        condition = params.get('condition')
        if condition and callable(condition):
            return data[condition(data)]
        return data
    
    def _create_column(self, data: pd.DataFrame, params: Dict[str, Any]) -> pd.DataFrame:
        \"\"\"創(chuàng)建新列\(zhòng)"\"\"
        column_name = params.get('column_name')
        expression = params.get('expression')
        
        if column_name and expression and callable(expression):
            data[column_name] = expression(data)
        
        return data
    
    def _drop_columns(self, data: pd.DataFrame, params: Dict[str, Any]) -> pd.DataFrame:
        \"\"\"刪除列\(zhòng)"\"\"
        columns = params.get('columns', [])
        return data.drop(columns=columns, errors='ignore')
    
    def _aggregate(self, data: pd.DataFrame, params: Dict[str, Any]) -> pd.DataFrame:
        \"\"\"數(shù)據(jù)聚合\"\"\"
        group_by = params.get('group_by', [])
        aggregations = params.get('aggregations', {})
        
        if group_by and aggregations:
            return data.groupby(group_by).agg(aggregations).reset_index()
        
        return data
''')
    
    # 創(chuàng)建CLI模塊
    cli_code = '''import click
from data_processor.core import DataProcessor
import logging
import json

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

@click.group()
def cli():
    """數(shù)據(jù)處理器命令行接口"""
    pass

@cli.command()
@click.argument('input_file')
@click.option('--output', '-o', help='輸出文件路徑')
@click.option('--format', '-f', type=click.Choice(['csv', 'json']), default='csv', help='輸出格式')
def process(input_file, output, format):
    """處理數(shù)據(jù)文件"""
    try:
        processor = DataProcessor()
        
        # 加載數(shù)據(jù)
        processor.load_data(input_file)
        
        # 基本清洗
        processor.clean(missing_strategy='fill', fill_values={})
        
        # 分析數(shù)據(jù)
        analysis = processor.analyze()
        
        click.echo("數(shù)據(jù)分析結果:")
        click.echo(json.dumps(analysis, indent=2, ensure_ascii=False))
        
        # 保存結果
        if output:
            processor.save(output)
            click.echo(f"結果已保存到: {output}")
        else:
            # 如果沒有指定輸出文件，顯示前幾行
            data = processor.get_data()
            click.echo("處理后的數(shù)據(jù)（前5行）:")
            click.echo(data.head().to_string())
            
    except Exception as e:
        click.echo(f"處理失敗: {e}", err=True)

@cli.command()
@click.argument('input_file')
def analyze(input_file):
    """分析數(shù)據(jù)文件"""
    try:
        processor = DataProcessor()
        processor.load_data(input_file)
        analysis = processor.analyze()
        
        click.echo("數(shù)據(jù)分析報告:")
        click.echo(f"數(shù)據(jù)形狀: {analysis['shape']}")
        click.echo(f"列名: {', '.join(analysis['columns'])}")
        click.echo(f"內存使用: {analysis['memory_usage']} bytes")
        
        if 'numeric_stats' in analysis:
            click.echo("\\n數(shù)值列統(tǒng)計:")
            for col, stats in analysis['numeric_stats'].items():
                click.echo(f"  {col}: count={stats['count']}, mean={stats['mean']:.2f}")
                
    except Exception as e:
        click.echo(f"分析失敗: {e}", err=True)

def main():
    """主函數(shù)"""
    cli()

if __name__ == '__main__':
    main()
'''
    
    with open('data_processor/cli.py', 'w') as f:
        f.write(cli_code)
    
    # 創(chuàng)建測試文件
    test_code = '''import pytest
import pandas as pd
import os
from data_processor.core import DataProcessor
from data_processor.loaders import CSVLoader, JSONLoader

@pytest.fixture
def sample_data():
    """創(chuàng)建樣本數(shù)據(jù)"""
    return pd.DataFrame({
        'name': ['Alice', 'Bob', 'Charlie', None],
        'age': [25, 30, 35, 40],
        'score': [85.5, 92.0, 78.5, 88.0]
    })

@pytest.fixture
def sample_csv(tmp_path):
    """創(chuàng)建樣本CSV文件"""
    data = pd.DataFrame({
        'name': ['Alice', 'Bob', 'Charlie'],
        'age': [25, 30, 35],
        'score': [85.5, 92.0, 78.5]
    })
    file_path = tmp_path / "test.csv"
    data.to_csv(file_path, index=False)
    return str(file_path)

def test_data_processor_initialization():
    """測試數(shù)據(jù)處理器初始化"""
    processor = DataProcessor()
    assert processor.data is None
    assert processor.transformations == []

def test_load_data_from_dataframe(sample_data):
    """測試從DataFrame加載數(shù)據(jù)"""
    processor = DataProcessor()
    processor.load_data(sample_data)
    assert processor.data is not None
    assert processor.data.shape == sample_data.shape

def test_csv_loader(sample_csv):
    """測試CSV加載器"""
    loader = CSVLoader()
    data = loader.load(sample_csv)
    assert data is not None
    assert len(data) == 3
    assert 'name' in data.columns

def test_data_cleaning(sample_data):
    """測試數(shù)據(jù)清洗"""
    processor = DataProcessor()
    processor.load_data(sample_data)
    processor.clean(missing_strategy='drop')
    assert processor.data is not None
    # 清洗后應該沒有缺失值
    assert not processor.data.isnull().any().any()

def test_data_analysis(sample_data):
    """測試數(shù)據(jù)分析"""
    processor = DataProcessor()
    processor.load_data(sample_data)
    analysis = processor.analyze()
    assert 'shape' in analysis
    assert 'columns' in analysis
    assert analysis['shape'] == sample_data.shape
'''
    
    with open('tests/test_core.py', 'w') as f:
        f.write(test_code)
    
    # 更新README.md
    readme_content = '''# Data Processor

一個強大的數(shù)據(jù)處理Python包，提供數(shù)據(jù)加載、清洗、轉換和分析功能。

## 功能特性

- ?? 多格式數(shù)據(jù)加載 (CSV, JSON)
- ?? 智能數(shù)據(jù)清洗
- ?? 靈活數(shù)據(jù)轉換
- ?? 全面數(shù)據(jù)分析
- ??? 命令行界面

## 安裝

使用Poetry安裝：

```bash
poetry install

from data_processor.core import DataProcessor

# 創(chuàng)建處理器實例
processor = DataProcessor()

# 加載和處喿數(shù)據(jù)
result = (processor
    .load_data('data.csv')
    .clean(missing_strategy='fill')
    .transform([
        {'type': 'rename_columns', 'params': {'mapping': {'old_name': 'new_name'}}}
    ])
    .analyze())

print(result)

# 處理數(shù)據(jù)文件
poetry run process-data process data.csv --output result.csv

# 分析數(shù)據(jù)文件
poetry run process-data analyze data.csv

poetry run pytest

poetry run black .

poetry run mypy .

with open('README.md', 'w') as f:
    f.write(readme_content)

print("Poetry項目設置完成！")
print("\n下一步:")
print("1. 運行: poetry install")
print("2. 運行: poetry shell")
print("3. 運行測試: poetry run pytest")
print("4. 嘗試CLI: poetry run process-data --help")

if name == “main”:
if len(sys.argv) > 1:
setup_poetry_project(sys.argv[1])
else:
setup_poetry_project()

# 構建包
poetry build

# 發(fā)布到PyPI
poetry publish

# 版本管理
poetry version patch  # 0.1.0 -> 0.1.1
poetry version minor  # 0.1.1 -> 0.2.0
poetry version major  # 0.2.0 -> 1.0.0

# 顯示依賴更新
poetry show --outdated

# 更新依賴
poetry update

# pyproject.toml 中的依賴組
[tool.poetry.group.test.dependencies]
pytest = "^7.0.0"
pytest-cov = "^4.0.0"

[tool.poetry.group.docs.dependencies]
sphinx = "^5.0.0"
sphinx-rtd-theme = "^1.0.0"

# 可選依賴
[tool.poetry.dependencies]
mysql = { version = "^0.10.0", optional = true }
postgresql = { version = "^0.10.0", optional = true }

[tool.poetry.extras]
mysql = ["mysql"]
postgresql = ["postgresql"]

# 配置虛擬環(huán)境路徑
poetry config virtualenvs.path /path/to/venvs

# 禁用虛擬環(huán)境創(chuàng)建
poetry config virtualenvs.create false

# 顯示配置
poetry config --list

#!/usr/bin/env python3
"""
Poetry vs Pipenv 功能對比分析

這個腳本生成詳細的功能對比表格和分析
"""

def generate_comparison_table():
    """生成功能對比表格"""
    
    comparison_data = [
        {
            'feature': '虛擬環(huán)境管理',
            'poetry': '? 自動創(chuàng)建和管理，可配置路徑',
            'pipenv': '? 自動創(chuàng)建和管理，可配置路徑',
            'description': '兩者都提供自動化的虛擬環(huán)境管理'
        },
        {
            'feature': '依賴解析',
            'poetry': '? 使用高效的SAT解析器',
            'pipenv': '? 使用pip-tools的解析器',
            'description': 'Poetry的解析器通常更快更可靠'
        },
        {
            'feature': '鎖定文件',
            'poetry': '? poetry.lock (TOML格式)',
            'pipenv': '? Pipfile.lock (JSON格式)',
            'description': '兩者都提供確定性構建'
        },
        {
            'feature': '包發(fā)布',
            'poetry': '? 內置支持，完整的發(fā)布工作流',
            'pipenv': '? 需要額外工具',
            'description': 'Poetry更適合包開發(fā)者'
        },
        {
            'feature': '配置文件',
            'poetry': '? pyproject.toml (PEP 621)',
            'pipenv': '? Pipfile (TOML格式)',
            'description': 'Poetry使用標準pyproject.toml'
        },
        {
            'feature': '依賴組',
            'poetry': '? 支持任意依賴組',
            'pipenv': '? 僅支持dev依賴',
            'description': 'Poetry的依賴組更靈活'
        },
        {
            'feature': '腳本管理',
            'poetry': '? 內置腳本支持',
            'pipenv': '? 需要外部工具',
            'description': 'Poetry可以定義包腳本'
        },
        {
            'feature': '性能',
            'poetry': '? 通常更快',
            'pipenv': '?? 有時較慢',
            'description': 'Poetry的依賴解析優(yōu)化更好'
        },
        {
            'feature': '社區(qū)生態(tài)',
            'poetry': '? 快速增長，現(xiàn)代工具鏈',
            'pipenv': '? 成熟穩(wěn)定，Python官方推薦過',
            'description': '兩者都有活躍的社區(qū)'
        },
        {
            'feature': '學習曲線',
            'poetry': '?? 稍陡峭，功能更多',
            'pipenv': '? 相對簡單',
            'description': 'Pipenv對新手更友好'
        }
    ]
    
    print("Poetry vs Pipenv 功能對比")
    print("=" * 80)
    print(f"{'功能':<15} {'Poetry':<30} {'Pipenv':<30} {'說明'}")
    print("-" * 80)
    
    for item in comparison_data:
        print(f"{item['feature']:<15} {item['poetry']:<30} {item['pipenv']:<30} {item['description']}")
    
    return comparison_data

def performance_analysis():
    """性能對比分析"""
    
    print("\n\n性能對比分析")
    print("=" * 50)
    
    performance_data = [
        {
            'operation': '依賴解析',
            'poetry': '快速，使用SAT求解器',
            'pipenv': '較慢，使用pip-tools',
            'impact': '大型項目差異明顯'
        },
        {
            'operation': '安裝速度',
            'poetry': '優(yōu)化過的并行安裝',
            'pipenv': '基于pip的串行安裝',
            'impact': 'Poetry通常快30-50%'
        },
        {
            'operation': '鎖定文件生成',
            'poetry': '快速，增量更新',
            'pipenv': '較慢，完全重新解析',
            'impact': '頻繁更新時差異明顯'
        },
        {
            'operation': '內存使用',
            'poetry': '中等',
            'pipenv': '較高',
            'impact': '大型項目Pipenv內存占用更多'
        }
    ]
    
    for item in performance_data:
        print(f"{item['operation']:<15} | {item['poetry']:<25} | {item['pipenv']:<25} | {item['impact']}")

def use_case_recommendations():
    """使用場景推薦"""
    
    print("\n\n使用場景推薦")
    print("=" * 50)
    
    recommendations = [
        {
            'scenario': '開源Python包開發(fā)',
            'recommendation': 'Poetry',
            'reason': '內置發(fā)布功能和完整的包管理'
        },
        {
            'scenario': 'Web應用開發(fā)',
            'recommendation': '均可，根據(jù)團隊偏好選擇',
            'reason': '兩者都適合應用依賴管理'
        },
        {
            'scenario': '數(shù)據(jù)科學項目',
            'recommendation': 'Poetry',
            'reason': '更好的性能和對復雜依賴的處理'
        },
        {
            'scenario': '初學者項目',
            'recommendation': 'Pipenv',
            'reason': '學習曲線更平緩'
        },
        {
            'scenario': '企業(yè)大型項目',
            'recommendation': 'Poetry',
            'reason': '更好的性能和可擴展性'
        },
        {
            'scenario': '需要與現(xiàn)有工具集成',
            'recommendation': '根據(jù)生態(tài)系統(tǒng)選擇',
            'reason': '檢查現(xiàn)有CI/CD和工作流支持'
        }
    ]
    
    for item in recommendations:
        print(f"{item['scenario']:<20} | {item['recommendation']:<30} | {item['reason']}")

def migration_guidance():
    """遷移指南"""
    
    print("\n\n遷移指南")
    print("=" * 50)
    
    print("從 requirements.txt 到 Pipenv:")
    print("  1. pipenv install -r requirements.txt")
    print("  2. 手動創(chuàng)建Pipfile定義開發(fā)依賴")
    print("  3. pipenv lock 生成鎖定文件")
    print("")
    
    print("從 Pipenv 到 Poetry:")
    print("  1. poetry init 創(chuàng)建pyproject.toml")
    print("  2. 手動遷移Pipfile中的依賴到pyproject.toml")
    print("  3. poetry install 安裝依賴")
    print("  4. 更新CI/CD和部署腳本")
    print("")
    
    print("從 requirements.txt 直接到 Poetry:")
    print("  1. poetry init --no-interaction")
    print("  2. poetry add $(cat requirements.txt)")
    print("  3. 添加開發(fā)依賴: poetry add --dev pytest black etc.")

if __name__ == "__main__":
    generate_comparison_table()
    performance_analysis()
    use_case_recommendations()
    migration_guidance()

#!/usr/bin/env python3
"""
Poetry vs Pipenv 性能基準測試

這個腳本對兩個工具進行實際的性能測試
注意：需要在干凈的環(huán)境中運行
"""

import time
import subprocess
import os
import tempfile
import shutil
import statistics

def run_command(cmd, cwd=None):
    """運行命令并返回執(zhí)行時間"""
    start_time = time.time()
    try:
        result = subprocess.run(
            cmd, 
            shell=True, 
            cwd=cwd, 
            capture_output=True, 
            text=True,
            timeout=300  # 5分鐘超時
        )
        elapsed = time.time() - start_time
        return elapsed, result.returncode == 0, result.stderr
    except subprocess.TimeoutExpired:
        return 300, False, "Command timed out"

def create_test_project(dependencies):
    """創(chuàng)建測試項目"""
    project_dir = tempfile.mkdtemp()
    
    # 創(chuàng)建基本項目結構
    os.makedirs(os.path.join(project_dir, 'src', 'test_package'), exist_ok=True)
    
    # 創(chuàng)建__init__.py
    with open(os.path.join(project_dir, 'src', 'test_package', '__init__.py'), 'w') as f:
        f.write('__version__ = "0.1.0"')
    
    # 創(chuàng)建簡單的Python文件
    with open(os.path.join(project_dir, 'src', 'test_package', 'main.py'), 'w') as f:
        f.write('def hello():\n    return "Hello, World!"')
    
    return project_dir

def test_poetry_performance(dependencies, iterations=3):
    """測試Poetry性能"""
    print("測試Poetry性能...")
    times = []
    
    for i in range(iterations):
        project_dir = create_test_project(dependencies)
        
        try:
            # 初始化Poetry項目
            init_time, success, error = run_command('poetry init --no-interaction', project_dir)
            if not success:
                print(f"Poetry初始化失敗: {error}")
                continue
            
            # 添加依賴
            dep_times = []
            for dep in dependencies:
                time_taken, success, error = run_command(f'poetry add {dep}', project_dir)
                if success:
                    dep_times.append(time_taken)
                else:
                    print(f"添加依賴 {dep} 失敗: {error}")
            
            # 鎖定時間
            lock_time, success, error = run_command('poetry lock', project_dir)
            
            total_time = init_time + sum(dep_times) + lock_time
            times.append(total_time)
            print(f"第 {i+1} 次迭代: {total_time:.2f}秒")
            
        finally:
            shutil.rmtree(project_dir)
    
    if times:
        avg_time = statistics.mean(times)
        std_dev = statistics.stdev(times) if len(times) > 1 else 0
        print(f"Poetry平均時間: {avg_time:.2f}秒 (±{std_dev:.2f}秒)")
        return avg_time
    return None

def test_pipenv_performance(dependencies, iterations=3):
    """測試Pipenv性能"""
    print("測試Pipenv性能...")
    times = []
    
    for i in range(iterations):
        project_dir = create_test_project(dependencies)
        
        try:
            # 初始化Pipenv項目
            init_time, success, error = run_command('pipenv install', project_dir)
            if not success:
                print(f"Pipenv初始化失敗: {error}")
                continue
            
            # 添加依賴
            dep_times = []
            for dep in dependencies:
                time_taken, success, error = run_command(f'pipenv install {dep}', project_dir)
                if success:
                    dep_times.append(time_taken)
                else:
                    print(f"添加依賴 {dep} 失敗: {error}")
            
            # 鎖定時間
            lock_time, success, error = run_command('pipenv lock', project_dir)
            
            total_time = init_time + sum(dep_times) + lock_time
            times.append(total_time)
            print(f"第 {i+1} 次迭代: {total_time:.2f}秒")
            
        finally:
            shutil.rmtree(project_dir)
    
    if times:
        avg_time = statistics.mean(times)
        std_dev = statistics.stdev(times) if len(times) > 1 else 0
        print(f"Pipenv平均時間: {avg_time:.2f}秒 (±{std_dev:.2f}秒)")
        return avg_time
    return None

def main():
    """主測試函數(shù)"""
    
    # 測試不同的依賴組合
    test_scenarios = [
        {
            'name': '簡單項目 (5個依賴)',
            'dependencies': ['requests', 'click', 'python-dotenv', 'colorama', 'tqdm']
        },
        {
            'name': '數(shù)據(jù)科學項目 (8個依賴)', 
            'dependencies': ['numpy', 'pandas', 'matplotlib', 'scikit-learn', 'jupyter', 'seaborn', 'plotly', 'scipy']
        },
        {
            'name': 'Web項目 (6個依賴)',
            'dependencies': ['flask', 'django', 'fastapi', 'sqlalchemy', 'celery', 'redis']
        }
    ]
    
    results = {}
    
    for scenario in test_scenarios:
        print(f"\n{'='*50}")
        print(f"測試場景: {scenario['name']}")
        print(f"依賴: {', '.join(scenario['dependencies'])}")
        print('='*50)
        
        poetry_time = test_poetry_performance(scenario['dependencies'], iterations=2)
        pipenv_time = test_pipenv_performance(scenario['dependencies'], iterations=2)
        
        if poetry_time and pipenv_time:
            speedup = pipenv_time / poetry_time
            results[scenario['name']] = {
                'poetry': poetry_time,
                'pipenv': pipenv_time,
                'speedup': speedup
            }
    
    # 輸出結果總結
    print(f"\n{'='*60}")
    print("性能測試結果總結")
    print('='*60)
    
    for scenario, result in results.items():
        print(f"\n{scenario}:")
        print(f"  Poetry: {result['poetry']:.2f}秒")
        print(f"  Pipenv: {result['pipenv']:.2f}秒")
        print(f"  Poetry比Pipenv快 {result['speedup']:.2f}倍")

if __name__ == "__main__":
    # 檢查工具是否安裝
    for tool in ['poetry', 'pipenv']:
        if subprocess.run(f"which {tool}", shell=True, capture_output=True).returncode != 0:
            print(f"錯誤: {tool} 未安裝")
            exit(1)
    
    main()

#!/usr/bin/env python3
"""
從Pipenv遷移到Poetry的完整示例

這個腳本演示如何將現(xiàn)有的Pipenv項目遷移到Poetry
"""

import os
import toml
import json
import shutil
from pathlib import Path

class PipenvToPoetryMigrator:
    """Pipenv到Poetry遷移器"""
    
    def __init__(self, project_path):
        self.project_path = Path(project_path)
        self.pipfile_path = self.project_path / 'Pipfile'
        self.pipfile_lock_path = self.project_path / 'Pipfile.lock'
        
    def validate_environment(self):
        """驗證環(huán)境"""
        if not self.pipfile_path.exists():
            raise FileNotFoundError("Pipfile not found")
        
        # 檢查Poetry是否安裝
        try:
            import subprocess
            subprocess.run(['poetry', '--version'], check=True, capture_output=True)
        except (subprocess.CalledProcessError, FileNotFoundError):
            raise RuntimeError("Poetry is not installed or not in PATH")
    
    def parse_pipfile(self):
        """解析Pipfile"""
        pipfile_data = toml.load(self.pipfile_path)
        
        packages = pipfile_data.get('packages', {})
        dev_packages = pipfile_data.get('dev-packages', {})
        
        return packages, dev_packages
    
    def parse_pipfile_lock(self):
        """解析Pipfile.lock"""
        if not self.pipfile_lock_path.exists():
            return {}, {}
        
        with open(self.pipfile_lock_path, 'r') as f:
            lock_data = json.load(f)
        
        default = lock_data.get('default', {})
        develop = lock_data.get('develop', {})
        
        return default, develop
    
    def convert_dependency_format(self, dependencies):
        """轉換依賴格式"""
        converted = {}
        
        for package, spec in dependencies.items():
            if isinstance(spec, str):
                if spec == '*':
                    converted[package] = '^latest'
                else:
                    # 處理版本說明符
                    converted[package] = self._normalize_version_spec(spec)
            elif isinstance(spec, dict):
                # 處理復雜依賴說明
                version = spec.get('version', '')
                markers = spec.get('markers', '')
                
                if version:
                    dep_spec = self._normalize_version_spec(version)
                    if markers:
                        dep_spec += f' ; {markers}'
                    converted[package] = dep_spec
            else:
                converted[package] = '*'
        
        return converted
    
    def _normalize_version_spec(self, spec):
        """標準化版本說明符"""
        if not spec or spec == '*':
            return '*'
        
        # 移除不必要的空格
        spec = spec.strip()
        
        # 處理常見的版本說明符
        if spec.startswith('=='):
            return spec
        elif spec.startswith('>='):
            version = spec[2:]
            return f'^{version}'
        elif spec.startswith('~='):
            version = spec[2:]
            return f'~{version}'
        else:
            return spec
    
    def create_pyproject_toml(self, packages, dev_packages, metadata=None):
        """創(chuàng)建pyproject.toml文件"""
        
        # 基本元數(shù)據(jù)
        metadata = metadata or {}
        project_name = metadata.get('name', Path(self.project_path).name)
        version = metadata.get('version', '0.1.0')
        description = metadata.get('description', '')
        authors = metadata.get('authors', ['Your Name <you@example.com>'])
        
        pyproject = {
            'tool': {
                'poetry': {
                    'name': project_name,
                    'version': version,
                    'description': description,
                    'authors': authors if isinstance(authors, list) else [authors],
                    'packages': [{'include': project_name.replace('-', '_')}],
                }
            },
            'build-system': {
                'requires': ['poetry-core>=1.0.0'],
                'build-backend': 'poetry.core.masonry.api'
            }
        }
        
        # 添加依賴
        if packages:
            pyproject['tool']['poetry']['dependencies'] = packages
            pyproject['tool']['poetry']['dependencies']['python'] = '^3.8'
        
        # 添加開發(fā)依賴
        if dev_packages:
            pyproject['tool']['poetry']['group'] = {
                'dev': {
                    'dependencies': dev_packages
                }
            }
        
        return pyproject
    
    def backup_existing_files(self):
        """備份現(xiàn)有文件"""
        backup_dir = self.project_path / 'backup_migration'
        backup_dir.mkdir(exist_ok=True)
        
        files_to_backup = ['Pipfile', 'Pipfile.lock', 'pyproject.toml']
        
        for file_name in files_to_backup:
            file_path = self.project_path / file_name
            if file_path.exists():
                shutil.copy2(file_path, backup_dir / file_name)
                print(f"已備份: {file_name}")
    
    def migrate(self, metadata=None):
        """執(zhí)行遷移"""
        print("開始從Pipenv遷移到Poetry...")
        
        # 驗證環(huán)境
        self.validate_environment()
        
        # 備份文件
        self.backup_existing_files()
        
        # 解析現(xiàn)有配置
        packages, dev_packages = self.parse_pipfile()
        lock_packages, lock_dev_packages = self.parse_pipfile_lock()
        
        print(f"發(fā)現(xiàn) {len(packages)} 個生產依賴")
        print(f"發(fā)現(xiàn) {len(dev_packages)} 個開發(fā)依賴")
        
        # 轉換依賴格式
        converted_packages = self.convert_dependency_format(packages)
        converted_dev_packages = self.convert_dependency_format(dev_packages)
        
        # 創(chuàng)建pyproject.toml
        pyproject_data = self.create_pyproject_toml(
            converted_packages, 
            converted_dev_packages, 
            metadata
        )
        
        # 寫入文件
        pyproject_path = self.project_path / 'pyproject.toml'
        with open(pyproject_path, 'w') as f:
            toml.dump(pyproject_data, f)
        
        print("已創(chuàng)建 pyproject.toml")
        
        # 使用Poetry安裝依賴
        print("使用Poetry安裝依賴...")
        os.chdir(self.project_path)
        
        import subprocess
        result = subprocess.run(['poetry', 'install'], capture_output=True, text=True)
        
        if result.returncode == 0:
            print("? 遷移成功完成!")
            print("\n下一步:")
            print("1. 驗證依賴: poetry run python -c 'import requests' # 示例")
            print("2. 運行測試: poetry run pytest")
            print("3. 更新CI/CD配置使用Poetry")
            print("4. 刪除備份文件: rm -rf backup_migration/")
        else:
            print("? 依賴安裝失敗:")
            print(result.stderr)
            
        return result.returncode == 0

def main():
    """主函數(shù)"""
    import argparse
    
    parser = argparse.ArgumentParser(description='從Pipenv遷移到Poetry')
    parser.add_argument('project_path', help='項目路徑')
    parser.add_argument('--name', help='項目名稱')
    parser.add_argument('--version', default='0.1.0', help='項目版本')
    parser.add_argument('--description', help='項目描述')
    parser.add_argument('--author', help='作者信息')
    
    args = parser.parse_args()
    
    metadata = {}
    if args.name:
        metadata['name'] = args.name
    if args.version:
        metadata['version'] = args.version
    if args.description:
        metadata['description'] = args.description
    if args.author:
        metadata['authors'] = [args.author]
    
    migrator = PipenvToPoetryMigrator(args.project_path)
    
    try:
        success = migrator.migrate(metadata)
        exit(0 if success else 1)
    except Exception as e:
        print(f"遷移失敗: {e}")
        exit(1)

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Poetry vs Pipenv 選擇指南

根據(jù)項目需求推薦合適的工具
"""

def get_tool_recommendation(project_type, team_size, requirements):
    """
    根據(jù)項目特征推薦工具
    
    Args:
        project_type: 項目類型 ('package', 'webapp', 'data_science', 'script')
        team_size: 團隊規(guī)模 ('solo', 'small', 'large')
        requirements: 需求列表 ['performance', 'publishing', 'simplicity', 'ci_cd']
    """
    
    recommendations = {
        'package': {
            'tool': 'Poetry',
            'reason': '包開發(fā)需要發(fā)布功能和完整的元數(shù)據(jù)管理',
            'confidence': 95
        },
        'webapp': {
            'tool': '根據(jù)團隊偏好選擇',
            'reason': '兩者都適合Web應用，Poetry性能更好，Pipenv更簡單',
            'confidence': 70
        },
        'data_science': {
            'tool': 'Poetry', 
            'reason': '數(shù)據(jù)科學項目通常有復雜的依賴，Poetry處理更好',
            'confidence': 85
        },
        'script': {
            'tool': 'Pipenv',
            'reason': '簡單腳本項目不需要Poetry的復雜功能',
            'confidence': 80
        }
    }
    
    base_recommendation = recommendations.get(project_type, {
        'tool': 'Poetry',
        'reason': '默認推薦Poetry，因為其更好的性能和功能',
        'confidence': 75
    })
    
    # 根據(jù)需求調整推薦
    if 'publishing' in requirements:
        base_recommendation = {
            'tool': 'Poetry',
            'reason': '包發(fā)布是Poetry的核心功能',
            'confidence': 100
        }
    elif 'simplicity' in requirements and team_size in ['solo', 'small']:
        base_recommendation = {
            'tool': 'Pipenv', 
            'reason': '小團隊和簡單項目更適合Pipenv的簡潔性',
            'confidence': 80
        }
    elif 'performance' in requirements and team_size == 'large':
        base_recommendation = {
            'tool': 'Poetry',
            'reason': '大型團隊和性能敏感項目適合Poetry',
            'confidence': 90
        }
    
    return base_recommendation

def print_recommendation(project_type, team_size, requirements):
    """打印推薦結果"""
    recommendation = get_tool_recommendation(project_type, team_size, requirements)
    
    print("工具選擇推薦")
    print("=" * 50)
    print(f"項目類型: {project_type}")
    print(f"團隊規(guī)模: {team_size}")
    print(f"關鍵需求: {', '.join(requirements)}")
    print("-" * 50)
    print(f"推薦工具: {recommendation['tool']}")
    print(f"推薦理由: {recommendation['reason']}")
    print(f"置信度: {recommendation['confidence']}%")
    print("=" * 50)

# 示例使用
if __name__ == "__main__":
    test_cases = [
        ('package', 'small', ['publishing', 'performance']),
        ('webapp', 'large', ['performance', 'ci_cd']),
        ('data_science', 'solo', ['simplicity']),
        ('script', 'solo', ['simplicity']),
    ]
    
    for project_type, team_size, requirements in test_cases:
        print_recommendation(project_type, team_size, requirements)
        print()

#!/usr/bin/env python3
"""
Python依賴管理最佳實踐
"""

def print_best_practices():
    """打印依賴管理最佳實踐"""
    
    practices = [
        {
            'category': '版本控制',
            'practices': [
                '始終提交鎖定文件到版本控制',
                '使用語義化版本控制',
                '在生產環(huán)境使用鎖定文件安裝'
            ]
        },
        {
            'category': '依賴管理',
            'practices': [
                '明確區(qū)分生產依賴和開發(fā)依賴',
                '定期更新依賴以獲取安全補丁',
                '使用依賴組組織相關依賴',
                '避免過度指定版本約束'
            ]
        },
        {
            'category': '安全',
            'practices': [
                '定期運行安全掃描',
                '使用私有倉庫管理內部包',
                '驗證依賴的完整性和來源',
                '監(jiān)控已知漏洞數(shù)據(jù)庫'
            ]
        },
        {
            'category': 'CI/CD',
            'practices': [
                '在CI中使用緩存加速依賴安裝',
                '測試時使用與生產相同的依賴',
                '自動化依賴更新和測試',
                '使用多階段構建優(yōu)化Docker鏡像'
            ]
        },
        {
            'category': '團隊協(xié)作', 
            'practices': [
                '統(tǒng)一團隊的依賴管理工具',
                '文檔化依賴管理流程',
                '代碼審查時檢查依賴變更',
                '建立依賴更新策略'
            ]
        }
    ]
    
    print("Python依賴管理最佳實踐")
    print("=" * 60)
    
    for category in practices:
        print(f"\n{category['category']}:")
        for practice in category['practices']:
            print(f"  ? {practice}")

def dependency_security_checklist():
    """依賴安全檢查清單"""
    
    checklist = [
        "是否定期更新依賴到最新安全版本？",
        "是否使用工具掃描依賴中的已知漏洞？",
        "是否驗證了依賴包的完整性和簽名？",
        "是否限制了依賴的安裝源？",
        "是否審查了依賴的許可證兼容性？",
        "是否監(jiān)控了依賴的更新和棄用通知？",
        "是否有回滾計劃應對有問題的依賴更新？",
        "是否文檔化了關鍵依賴的安全要求？"
    ]
    
    print("\n依賴安全檢查清單")
    print("=" * 50)
    for item in checklist:
        print(f"  [ ] {item}")

if __name__ == "__main__":
    print_best_practices()
    dependency_security_checklist()