# コメントを書くだけでコード生成
# CSVファイルを読み込んで売上データを分析する関数
def analyze_sales_data(csv_file):
import pandas as pd
import matplotlib.pyplot as plt
# データ読み込み
df = pd.read_csv(csv_file)
# 基本統計
total_sales = df['売上'].sum()
avg_sales = df['売上'].mean()
# 月別売上グラフ
monthly_sales = df.groupby('月')['売上'].sum()
monthly_sales.plot(kind='bar')
plt.title('月別売上推移')
plt.show()
return {
'total_sales': total_sales,
'avg_sales': avg_sales,
'monthly_data': monthly_sales
}

# ❌ 曖昧なプロンプト
# ユーザー管理
# ✅ 具体的で詳細なプロンプト
# ユーザー登録APIエンドポイント
# - メールアドレスとパスワードでユーザー作成
# - パスワードはbcryptでハッシュ化
# - 重複メールアドレスはエラー返却
# - 成功時はJWTトークンを返却
@app.route('/api/users/register', methods=['POST'])
def register_user():
data = request.get_json()
# メールアドレス重複チェック
if User.query.filter_by(email=data['email']).first():
return jsonify({'error': 'Email already exists'}), 400
# パスワードハッシュ化
hashed_password = bcrypt.generate_password_hash(data['password']).decode('utf-8')
# ユーザー作成
user = User(email=data['email'], password=hashed_password)
db.session.add(user)
db.session.commit()
# JWTトークン生成
token = jwt.encode({'user_id': user.id}, app.config['SECRET_KEY'])
return jsonify({'token': token, 'user_id': user.id}), 201

# models/user.py が存在する場合
from models.user import User
from models.order import Order
# 既存のモデル構造を理解してリレーション作成
class UserService:
@staticmethod
def get_user_with_orders(user_id):
        """ユーザーと注文履歴を取得"""
user = User.query.get(user_id)
if not user:
return None
orders = Order.query.filter_by(user_id=user_id).all()
return {
'user': {
'id': user.id,
'email': user.email,
'name': user.name
},
'orders': [
{
'id': order.id,
'total': order.total,
'status': order.status,
'created_at': order.created_at
}
for order in orders
]
}

# テストケースを先に書く
def test_user_registration():
    """ユーザー登録のテスト"""
# 正常ケース
response = client.post('/api/users/register', json={
'email': 'test@example.com',
'password': 'password123'
})
assert response.status_code == 201
assert 'token' in response.json
# 重複メールエラー
response = client.post('/api/users/register', json={
'email': 'test@example.com',
'password': 'password456'
})
assert response.status_code == 400
assert 'Email already exists' in response.json['error']
# テストに基づいて実装コードを生成
# Copilotがテストケースを参考に適切な実装を提案

# ❌ 改善前のコード
def process_data(data):
result = []
for item in data:
if item['status'] == 'active':
if item['score'] > 80:
if item['category'] == 'premium':
result.append({
'id': item['id'],
'name': item['name'],
'processed': True
})
return result
# ✅ Copilotが提案する改善後のコード
def process_data(data):
    """アクティブなプレミアム高スコアアイテムを処理"""
return [
{
'id': item['id'],
'name': item['name'],
'processed': True
}
for item in data
if (item['status'] == 'active' and 
item['score'] > 80 and 
item['category'] == 'premium')
]

class UserManager:
    """
    ユーザー管理クラス
    ユーザーの作成、更新、削除、検索機能を提供します。
    データベースとの接続はSQLAlchemyを使用し、
    パスワードの暗号化にはbcryptを使用します。
    Attributes:
        db: データベースセッション
        bcrypt: パスワード暗号化インスタンス
    Example:
        >>> user_manager = UserManager(db_session)
        >>> user = user_manager.create_user('test@example.com', 'password')
        >>> print(user.id)
    """
def __init__(self, db_session):
        """
        UserManagerを初期化
        Args:
            db_session: SQLAlchemyデータベースセッション
        """
self.db = db_session
self.bcrypt = Bcrypt()
def create_user(self, email: str, password: str) -> User:
        """
        新しいユーザーを作成
        Args:
            email (str): ユーザーのメールアドレス
            password (str): プレーンテキストパスワード
        Returns:
            User: 作成されたユーザーオブジェクト
        Raises:
            ValueError: メールアドレスが既に存在する場合
            ValidationError: 入力データが無効な場合
        """
# 実装コード...

# FastAPIでのCRUD API自動生成例
from fastapi import FastAPI, HTTPException, Depends
from sqlalchemy.orm import Session
from typing import List
app = FastAPI()
# ユーザー管理API
@app.post("/users/", response_model=UserResponse)
def create_user(user: UserCreate, db: Session = Depends(get_db)):
    """新しいユーザーを作成"""
db_user = User(**user.dict())
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
@app.get("/users/", response_model=List[UserResponse])
def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    """ユーザー一覧を取得"""
users = db.query(User).offset(skip).limit(limit).all()
return users
@app.get("/users/{user_id}", response_model=UserResponse)
def read_user(user_id: int, db: Session = Depends(get_db)):
    """特定のユーザーを取得"""
user = db.query(User).filter(User.id == user_id).first()
if user is None:
raise HTTPException(status_code=404, detail="User not found")
return user
@app.put("/users/{user_id}", response_model=UserResponse)
def update_user(user_id: int, user: UserUpdate, db: Session = Depends(get_db)):
    """ユーザー情報を更新"""
db_user = db.query(User).filter(User.id == user_id).first()
if db_user is None:
raise HTTPException(status_code=404, detail="User not found")
for key, value in user.dict(exclude_unset=True).items():
setattr(db_user, key, value)
db.commit()
db.refresh(db_user)
return db_user
@app.delete("/users/{user_id}")
def delete_user(user_id: int, db: Session = Depends(get_db)):
    """ユーザーを削除"""
db_user = db.query(User).filter(User.id == user_id).first()
if db_user is None:
raise HTTPException(status_code=404, detail="User not found")
db.delete(db_user)
db.commit()
return {"message": "User deleted successfully"}

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error, r2_score
def analyze_sales_prediction(data_file):
    """
    売上予測分析パイプライン
    1. データ読み込み・前処理
    2. 探索的データ分析
    3. 機械学習モデル構築
    4. 予測精度評価
    5. 結果可視化
    """
# データ読み込み
df = pd.read_csv(data_file)
# 基本統計情報
print("=== データ概要 ===")
print(df.info())
print("\n=== 基本統計 ===")
print(df.describe())
# 欠損値処理
df = df.dropna()
# 特徴量エンジニアリング
df['月'] = pd.to_datetime(df['日付']).dt.month
df['曜日'] = pd.to_datetime(df['日付']).dt.dayofweek
# 相関分析
plt.figure(figsize=(12, 8))
correlation_matrix = df.select_dtypes(include=[np.number]).corr()
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm')
plt.title('特徴量相関マトリックス')
plt.tight_layout()
plt.savefig('correlation_matrix.png')
plt.show()
# 機械学習モデル構築
features = ['価格', '広告費', '月', '曜日', '在庫数']
X = df[features]
y = df['売上']
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# ランダムフォレスト回帰
model = RandomForestRegressor(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
# 予測と評価
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f"\n=== モデル性能 ===")
print(f"MSE: {mse:.2f}")
print(f"R²スコア: {r2:.3f}")
# 特徴量重要度
feature_importance = pd.DataFrame({
'特徴量': features,
'重要度': model.feature_importances_
}).sort_values('重要度', ascending=False)
plt.figure(figsize=(10, 6))
sns.barplot(data=feature_importance, x='重要度', y='特徴量')
plt.title('特徴量重要度')
plt.tight_layout()
plt.savefig('feature_importance.png')
plt.show()
# 予測結果の可視化
plt.figure(figsize=(10, 6))
plt.scatter(y_test, y_pred, alpha=0.6)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
plt.xlabel('実際の売上')
plt.ylabel('予測売上')
plt.title('売上予測結果')
plt.tight_layout()
plt.savefig('prediction_results.png')
plt.show()
return model, feature_importance
# 実行例
model, importance = analyze_sales_prediction('sales_data.csv')

// ユーザー管理ダッシュボードコンポーネント
import React, { useState, useEffect } from 'react';
import { User, UserService } from '../services/userService';
interface UserDashboardProps {
    onUserSelect?: (user: User) => void;
}
const UserDashboard: React.FC<UserDashboardProps> = ({ onUserSelect }) => {
    const [users, setUsers] = useState<User[]>([]);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState<string | null>(null);
    const [searchTerm, setSearchTerm] = useState('');
    const [sortBy, setSortBy] = useState<'name' | 'email' | 'createdAt'>('name');
    useEffect(() => {
        fetchUsers();
    }, []);
    const fetchUsers = async () => {
        try {
            setLoading(true);
            const userData = await UserService.getAllUsers();
            setUsers(userData);
        } catch (err) {
            setError('ユーザーデータの取得に失敗しました');
        } finally {
            setLoading(false);
        }
    };
    const filteredUsers = users
        .filter(user => 
            user.name.toLowerCase().includes(searchTerm.toLowerCase()) ||
            user.email.toLowerCase().includes(searchTerm.toLowerCase())
        )
        .sort((a, b) => {
            if (sortBy === 'createdAt') {
                return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
            }
            return a[sortBy].localeCompare(b[sortBy]);
        });
    if (loading) return <div className="loading">読み込み中...</div>;
    if (error) return <div className="error">{error}</div>;
    return (
        <div className="user-dashboard">
            <div className="dashboard-header">
                <h2>ユーザー管理</h2>
                <div className="controls">
                    <input
                        type="text"
                        placeholder="ユーザーを検索..."
                        value={searchTerm}
                        onChange={(e) => setSearchTerm(e.target.value)}
                        className="search-input"
                    />
                    <select
                        value={sortBy}
                        onChange={(e) => setSortBy(e.target.value as any)}
                        className="sort-select"
                    >
                        <option value="name">名前順</option>
                        <option value="email">メール順</option>
                        <option value="createdAt">登録日順</option>
                    </select>
                </div>
            </div>
            <div className="user-grid">
                {filteredUsers.map(user => (
                    <div
                        key={user.id}
                        className="user-card"
                        onClick={() => onUserSelect?.(user)}
                    >
                        <div className="user-avatar">
                            {user.name.charAt(0).toUpperCase()}
                        </div>
                        <div className="user-info">
                            <h3>{user.name}</h3>
                            <p>{user.email}</p>
                            <span className="user-date">
                                {new Date(user.createdAt).toLocaleDateString()}
                            </span>
                        </div>
                    </div>
                ))}
            </div>
            {filteredUsers.length === 0 && (
                <div className="no-results">
                    検索条件に一致するユーザーが見つかりません
                </div>
            )}
        </div>
    );
};
export default UserDashboard;

# Copilot生成コードも必ずレビュー
def validate_copilot_code():
    """
    Copilot生成コードの品質チェックポイント
    1. ロジックの正確性
    2. エラーハンドリング
    3. セキュリティ考慮
    4. パフォーマンス
    5. 可読性
    """
# 例: 生成されたコードの改善
# ❌ Copilot初期生成
def process_user_data(data):
return [item for item in data if item['active']]
# ✅ レビュー後改善版
def process_user_data(data: List[Dict]) -> List[Dict]:
        """アクティブなユーザーデータのみを抽出"""
if not data:
return []
try:
return [
item for item in data 
if isinstance(item, dict) and item.get('active', False)
]
except (TypeError, KeyError) as e:
logger.error(f"データ処理エラー: {e}")
return []

# セキュリティを考慮したAPI実装
from flask import Flask, request, jsonify
from werkzeug.security import check_password_hash
import jwt
from functools import wraps
def require_auth(f):
@wraps(f)
def decorated_function(*args, **kwargs):
token = request.headers.get('Authorization')
if not token:
return jsonify({'error': 'Token missing'}), 401
try:
# Bearer トークンの処理
token = token.split(' ')[1]
data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
current_user_id = data['user_id']
except (jwt.ExpiredSignatureError, jwt.InvalidTokenError, IndexError):
return jsonify({'error': 'Invalid token'}), 401
return f(current_user_id, *args, **kwargs)
return decorated_function
@app.route('/api/protected', methods=['GET'])
@require_auth
def protected_endpoint(current_user_id):
    """認証が必要なエンドポイント"""
return jsonify({
'message': 'Protected data',
'user_id': current_user_id
})