# HR-VITON による試着画像生成 (擬似コード)
import torch
from hr_viton import HRVITONModel
from utils import load_image, preprocess
 
# モデルロード
model = HRVITONModel.from_pretrained("hr-viton-checkpoint")
model.to("cuda")
 
# 入力準備
person_image = load_image("person.jpg")           # ユーザー写真
garment_image = load_image("tshirt_catalog.jpg")   # 衣服カタログ画像
 
# 前処理: 人体パーシング + ポーズ推定
person_parse = segment_person(person_image)         # 体のパーツ分割
person_pose = estimate_pose(person_image)           # 関節位置推定
garment_mask = segment_garment(garment_image)       # 衣服領域抽出
 
# 試着画像生成
result = model.inference(
    person_image=person_image,
    garment_image=garment_image,
    person_parse=person_parse,
    person_pose=person_pose,
    garment_mask=garment_mask,
)
 
result.save("try_on_result.jpg")

# DensePose: 人体表面の UV マッピング
from detectron2 import model_zoo
from detectron2.engine import DefaultPredictor
from detectron2.config import get_cfg
from densepose.config import add_densepose_config
 
cfg = get_cfg()
add_densepose_config(cfg)
cfg.merge_from_file(model_zoo.get_config_file(
    "densepose_rcnn_R_101_FPN_DL_s1x.yaml"
))
cfg.MODEL.WEIGHTS = "densepose_model.pkl"
 
predictor = DefaultPredictor(cfg)
outputs = predictor(person_image)
 
# DensePose は人体の表面を UV 座標にマッピング
# → 衣服テクスチャを人体表面に正確に貼り付け可能

# 人体パーシング (LIP / ATR フォーマット)
# 各ピクセルを体のパーツに分類
 
# パーツラベル:
#  0: 背景, 1: 帽子, 2: 髪, 3: サングラス
#  4: 上着, 5: スカート, 6: パンツ, 7: ドレス
#  8: ベルト, 9: 左靴, 10: 右靴, 11: 顔
#  12: 左足, 13: 右足, 14: 左腕, 15: 右腕
#  16: バッグ, 17: スカーフ
 
from transformers import SegformerForSemanticSegmentation, SegformerImageProcessor
 
processor = SegformerImageProcessor.from_pretrained(
    "mattmdjaga/segformer_b2_clothes"
)
model = SegformerForSemanticSegmentation.from_pretrained(
    "mattmdjaga/segformer_b2_clothes"
)
 
inputs = processor(images=person_image, return_tensors="pt")
outputs = model(**inputs)
 
# 各ピクセルのパーツラベルを取得
parse_map = outputs.logits.argmax(dim=1).squeeze()

# OOTDiffusion: Outfitting Fusion ベースの試着モデル
# Stable Diffusion をベースとした最新の VTON 手法
 
import torch
from ootd.inference import OOTDInference
from PIL import Image
 
class OOTDiffusionPipeline:
    """OOTDiffusion による高品質バーチャル試着"""
 
    def __init__(self, model_path: str = "levihsu/OOTDiffusion"):
        self.model = OOTDInference(
            model_path=model_path,
            model_type="hd",  # "hd" (半身) or "dc" (全身)
        )
 
    def try_on(
        self,
        person_image_path: str,
        garment_image_path: str,
        category: str = "upperbody",
        num_samples: int = 1,
        num_steps: int = 20,
        guidance_scale: float = 2.0,
        seed: int = 42,
    ) -> list:
        """
        バーチャル試着を実行
 
        category:
          - "upperbody": 上半身（Tシャツ、シャツ、ジャケット等）
          - "lowerbody": 下半身（パンツ、スカート等）
          - "dress": ワンピース、ドレス
 
        guidance_scale:
          - 1.0-2.0: 自然な仕上がり
          - 2.0-3.0: 衣服のディテール重視
          - 3.0+: 過度に強調（アーティファクト注意）
        """
        person_img = Image.open(person_image_path).resize((768, 1024))
        garment_img = Image.open(garment_image_path).resize((768, 1024))
 
        results = self.model(
            category=category,
            image_garm=garment_img,
            image_vton=person_img,
            n_samples=num_samples,
            n_steps=num_steps,
            image_scale=guidance_scale,
            seed=seed,
        )
 
        return results
 
    def batch_try_on(
        self,
        person_image_path: str,
        garment_dir: str,
        output_dir: str,
        category: str = "upperbody",
    ) -> dict:
        """複数の衣服を一括で試着"""
        from pathlib import Path
        Path(output_dir).mkdir(parents=True, exist_ok=True)
 
        results = {}
        for garment_path in Path(garment_dir).glob("*.{jpg,png,jpeg}"):
            try:
                output = self.try_on(
                    person_image_path=person_image_path,
                    garment_image_path=str(garment_path),
                    category=category,
                )
                out_path = f"{output_dir}/{garment_path.stem}_tryon.png"
                output[0].save(out_path)
                results[garment_path.stem] = out_path
            except Exception as e:
                results[garment_path.stem] = f"Error: {e}"
 
        return results
 
 
# 使用例
pipeline = OOTDiffusionPipeline()
 
# 単一衣服の試着
result = pipeline.try_on(
    person_image_path="user_photo.jpg",
    garment_image_path="blue_tshirt.jpg",
    category="upperbody",
    num_samples=3,  # 3つのバリエーションを生成
    guidance_scale=2.0,
)
 
# 結果の保存
for i, img in enumerate(result):
    img.save(f"tryon_result_{i}.png")

# Thin Plate Spline (TPS) 変形
# 衣服画像をユーザーの体型に合わせて変形する手法
 
import numpy as np
import cv2
 
class ThinPlateSplineWarper:
    """TPS (薄板スプライン) による衣服変形"""
 
    def __init__(self, source_points: np.ndarray, target_points: np.ndarray):
        """
        source_points: 衣服画像上の制御点 (N, 2)
        target_points: ユーザー画像上の対応点 (N, 2)
        """
        self.source = source_points
        self.target = target_points
        self.n = len(source_points)
 
        # TPS パラメータの計算
        self._compute_parameters()
 
    def _compute_parameters(self):
        """TPS 変形パラメータを計算"""
        n = self.n
        K = np.zeros((n, n))
 
        for i in range(n):
            for j in range(n):
                if i != j:
                    r = np.linalg.norm(self.source[i] - self.source[j])
                    K[i, j] = r ** 2 * np.log(r + 1e-6)
 
        # 線形部分の行列
        P = np.hstack([np.ones((n, 1)), self.source])
 
        # 連立方程式の構築
        L = np.zeros((n + 3, n + 3))
        L[:n, :n] = K
        L[:n, n:] = P
        L[n:, :n] = P.T
 
        # 各軸について解く
        self.params_x = np.linalg.solve(
            L + np.eye(n + 3) * 1e-6,
            np.concatenate([self.target[:, 0], [0, 0, 0]])
        )
        self.params_y = np.linalg.solve(
            L + np.eye(n + 3) * 1e-6,
            np.concatenate([self.target[:, 1], [0, 0, 0]])
        )
 
    def warp_image(self, image: np.ndarray) -> np.ndarray:
        """画像を TPS 変形する"""
        h, w = image.shape[:2]
        output = np.zeros_like(image)
 
        for y in range(h):
            for x in range(w):
                point = np.array([x, y], dtype=float)
 
                # TPS による座標変換
                new_x = self._transform_point(point, self.params_x)
                new_y = self._transform_point(point, self.params_y)
 
                # バイリニア補間でピクセル値を取得
                if 0 <= new_x < w and 0 <= new_y < h:
                    output[y, x] = self._bilinear_interpolate(
                        image, new_x, new_y
                    )
 
        return output
 
    def _transform_point(self, point, params):
        """1点の座標変換"""
        result = params[self.n] + params[self.n + 1] * point[0] + params[self.n + 2] * point[1]
        for i in range(self.n):
            r = np.linalg.norm(point - self.source[i])
            if r > 0:
                result += params[i] * r ** 2 * np.log(r)
        return result
 
    def _bilinear_interpolate(self, image, x, y):
        """バイリニア補間"""
        x0 = int(np.floor(x))
        x1 = min(x0 + 1, image.shape[1] - 1)
        y0 = int(np.floor(y))
        y1 = min(y0 + 1, image.shape[0] - 1)
 
        dx = x - x0
        dy = y - y0
 
        return (
            image[y0, x0] * (1 - dx) * (1 - dy)
            + image[y0, x1] * dx * (1 - dy)
            + image[y1, x0] * (1 - dx) * dy
            + image[y1, x1] * dx * dy
        ).astype(np.uint8)

# MediaPipe + Three.js でリアルタイム AR 試着 (概念コード)
import mediapipe as mp
import cv2
 
mp_pose = mp.solutions.pose
pose = mp_pose.Pose(
    static_image_mode=False,
    model_complexity=1,
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5,
)
 
cap = cv2.VideoCapture(0)
 
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break
 
    # ポーズ推定
    results = pose.process(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
 
    if results.pose_landmarks:
        landmarks = results.pose_landmarks.landmark
        # 肩、腰、腕の座標を取得
        left_shoulder = landmarks[mp_pose.PoseLandmark.LEFT_SHOULDER]
        right_shoulder = landmarks[mp_pose.PoseLandmark.RIGHT_SHOULDER]
 
        # 衣服画像をポーズに合わせて変形・合成
        garment_overlay = warp_garment_to_pose(
            garment_image, landmarks, frame.shape
        )
        frame = overlay_transparent(frame, garment_overlay)
 
    cv2.imshow('Virtual Try-On', frame)

// WebAR を使ったブラウザベース試着
// Three.js + MediaPipe Holistic
 
class WebARTryOn {
  constructor(videoElement, canvasElement) {
    this.video = videoElement;
    this.canvas = canvasElement;
 
    // Three.js のセットアップ
    this.scene = new THREE.Scene();
    this.camera = new THREE.PerspectiveCamera(75, 16 / 9, 0.1, 1000);
    this.renderer = new THREE.WebGLRenderer({
      canvas: this.canvas,
      alpha: true,
    });
 
    // MediaPipe Pose の初期化
    this.pose = new Pose({
      locateFile: (file) => {
        return `https://cdn.jsdelivr.net/npm/@mediapipe/pose/${file}`;
      },
    });
 
    this.pose.setOptions({
      modelComplexity: 1,
      smoothLandmarks: true,
      minDetectionConfidence: 0.5,
      minTrackingConfidence: 0.5,
    });
 
    this.pose.onResults(this.onPoseResults.bind(this));
 
    // 衣服メッシュ
    this.garmentMesh = null;
  }
 
  async loadGarment(glbPath) {
    const loader = new THREE.GLTFLoader();
    const gltf = await loader.loadAsync(glbPath);
    this.garmentMesh = gltf.scene;
    this.scene.add(this.garmentMesh);
  }
 
  onPoseResults(results) {
    if (!results.poseLandmarks || !this.garmentMesh) return;
 
    const landmarks = results.poseLandmarks;
 
    // 肩の座標からスケールと位置を計算
    const leftShoulder = landmarks[11];
    const rightShoulder = landmarks[12];
    const leftHip = landmarks[23];
    const rightHip = landmarks[24];
 
    // 肩幅から衣服のスケーリング
    const shoulderWidth = Math.sqrt(
      Math.pow(rightShoulder.x - leftShoulder.x, 2) +
      Math.pow(rightShoulder.y - leftShoulder.y, 2)
    );
 
    // 体の中心座標
    const centerX = (leftShoulder.x + rightShoulder.x) / 2;
    const centerY = (leftShoulder.y + leftHip.y) / 2;
 
    // 体の傾きを計算
    const angle = Math.atan2(
      rightShoulder.y - leftShoulder.y,
      rightShoulder.x - leftShoulder.x
    );
 
    // メッシュの位置・回転・スケールを更新
    this.garmentMesh.position.set(
      (centerX - 0.5) * 4,
      -(centerY - 0.5) * 4,
      0
    );
    this.garmentMesh.rotation.z = angle;
    this.garmentMesh.scale.setScalar(shoulderWidth * 5);
 
    this.renderer.render(this.scene, this.camera);
  }
 
  async start() {
    const stream = await navigator.mediaDevices.getUserMedia({ video: true });
    this.video.srcObject = stream;
 
    const cameraLoop = new Camera(this.video, {
      onFrame: async () => {
        await this.pose.send({ image: this.video });
      },
      width: 1280,
      height: 720,
    });
    cameraLoop.start();
  }
}
 
// 使用例
const tryOn = new WebARTryOn(
  document.getElementById('video'),
  document.getElementById('canvas')
);
await tryOn.loadGarment('/models/tshirt.glb');
await tryOn.start();

# AI ベースのサイズ推薦システム
 
import numpy as np
from dataclasses import dataclass
 
@dataclass
class BodyMeasurements:
    """体型計測データ"""
    height_cm: float
    weight_kg: float
    chest_cm: float
    waist_cm: float
    hip_cm: float
    shoulder_width_cm: float
    arm_length_cm: float
    inseam_cm: float
 
class SizeRecommender:
    """体型データに基づくサイズ推薦"""
 
    # ブランドごとのサイズチャート（例）
    SIZE_CHARTS = {
        "standard_jp": {
            "S": {"chest": (80, 88), "waist": (68, 76), "hip": (82, 90)},
            "M": {"chest": (88, 96), "waist": (76, 84), "hip": (90, 98)},
            "L": {"chest": (96, 104), "waist": (84, 92), "hip": (98, 106)},
            "XL": {"chest": (104, 112), "waist": (92, 100), "hip": (106, 114)},
        },
    }
 
    def __init__(self, brand: str = "standard_jp"):
        self.size_chart = self.SIZE_CHARTS.get(brand, self.SIZE_CHARTS["standard_jp"])
 
    def estimate_body_from_image(self, image_path: str, height_cm: float) -> BodyMeasurements:
        """
        写真と身長から体型を推定
 
        実際の実装では:
        1. DensePose で体表面の UV マッピング
        2. SMPL / SMPL-X で 3D 体型パラメータ推定
        3. パラメータから各部位の寸法を計算
        """
        # SMPL モデルによる体型推定（擬似コード）
        from smpl_estimation import estimate_smpl_params
 
        smpl_params = estimate_smpl_params(image_path, height_cm)
 
        measurements = BodyMeasurements(
            height_cm=height_cm,
            weight_kg=smpl_params.estimated_weight,
            chest_cm=smpl_params.chest_circumference,
            waist_cm=smpl_params.waist_circumference,
            hip_cm=smpl_params.hip_circumference,
            shoulder_width_cm=smpl_params.shoulder_width,
            arm_length_cm=smpl_params.arm_length,
            inseam_cm=smpl_params.inseam,
        )
        return measurements
 
    def recommend_size(
        self,
        measurements: BodyMeasurements,
        garment_type: str = "top",
        fit_preference: str = "regular",
    ) -> dict:
        """
        サイズを推薦
 
        fit_preference: "slim", "regular", "loose"
        """
        # フィット調整（cm）
        fit_adjustment = {
            "slim": -2,
            "regular": 0,
            "loose": 4,
        }
        adj = fit_adjustment.get(fit_preference, 0)
 
        # 各サイズとの適合度を計算
        scores = {}
        for size, ranges in self.size_chart.items():
            score = 0
            if garment_type in ("top", "outerwear"):
                chest_mid = (ranges["chest"][0] + ranges["chest"][1]) / 2
                score += 1.0 - abs(measurements.chest_cm + adj - chest_mid) / 20
            if garment_type in ("bottom",):
                waist_mid = (ranges["waist"][0] + ranges["waist"][1]) / 2
                score += 1.0 - abs(measurements.waist_cm + adj - waist_mid) / 20
                hip_mid = (ranges["hip"][0] + ranges["hip"][1]) / 2
                score += 1.0 - abs(measurements.hip_cm + adj - hip_mid) / 20
 
            scores[size] = max(0, score)
 
        # 最適サイズ
        best_size = max(scores, key=scores.get)
        confidence = scores[best_size] / max(sum(scores.values()), 1e-6)
 
        return {
            "recommended_size": best_size,
            "confidence": round(confidence, 2),
            "scores": scores,
            "fit_preference": fit_preference,
            "note": f"バスト{measurements.chest_cm}cm に基づく推薦"
                    if garment_type == "top"
                    else f"ウエスト{measurements.waist_cm}cm に基づく推薦",
        }
 
 
# 使用例
recommender = SizeRecommender(brand="standard_jp")
 
measurements = BodyMeasurements(
    height_cm=170,
    weight_kg=65,
    chest_cm=92,
    waist_cm=78,
    hip_cm=94,
    shoulder_width_cm=44,
    arm_length_cm=58,
    inseam_cm=76,
)
 
result = recommender.recommend_size(
    measurements=measurements,
    garment_type="top",
    fit_preference="regular",
)
print(f"推薦サイズ: {result['recommended_size']}")
print(f"信頼度: {result['confidence']}")

# FastAPI を使ったバーチャル試着 API
 
from fastapi import FastAPI, File, UploadFile, HTTPException
from pydantic import BaseModel
from typing import Optional
import uuid
 
app = FastAPI(title="Virtual Try-On API")
 
class TryOnRequest(BaseModel):
    person_image_id: str
    garment_id: str
    category: str = "upperbody"  # upperbody, lowerbody, dress
    guidance_scale: float = 2.0
    num_samples: int = 1
 
class TryOnResponse(BaseModel):
    request_id: str
    status: str
    result_urls: list[str] = []
    processing_time_ms: float = 0
    size_recommendation: Optional[dict] = None
 
class VTONService:
    """バーチャル試着サービス"""
 
    def __init__(self):
        self.model = None  # 遅延ロード
        self._load_model()
 
    def _load_model(self):
        """モデルの遅延ロード"""
        import torch
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        # ここで VTON モデルをロード
        print(f"Model loaded on {self.device}")
 
    async def process_try_on(self, request: TryOnRequest) -> TryOnResponse:
        """試着リクエストを処理"""
        import time
        start = time.time()
 
        request_id = str(uuid.uuid4())
 
        try:
            # 画像取得
            person_img = await self._fetch_image(request.person_image_id)
            garment_img = await self._fetch_garment(request.garment_id)
 
            # 試着実行
            results = self._run_inference(
                person_img, garment_img,
                category=request.category,
                guidance_scale=request.guidance_scale,
                num_samples=request.num_samples,
            )
 
            # 結果保存
            result_urls = []
            for i, result in enumerate(results):
                url = await self._save_result(request_id, i, result)
                result_urls.append(url)
 
            elapsed = (time.time() - start) * 1000
 
            return TryOnResponse(
                request_id=request_id,
                status="completed",
                result_urls=result_urls,
                processing_time_ms=round(elapsed, 1),
            )
 
        except Exception as e:
            return TryOnResponse(
                request_id=request_id,
                status=f"error: {str(e)}",
            )
 
    def _run_inference(self, person_img, garment_img, **kwargs):
        """推論実行"""
        # 実際の推論ロジック
        pass
 
    async def _fetch_image(self, image_id):
        """S3 等から画像を取得"""
        pass
 
    async def _fetch_garment(self, garment_id):
        """カタログ DB から衣服画像を取得"""
        pass
 
    async def _save_result(self, request_id, index, image):
        """結果を S3 に保存"""
        pass
 
vton_service = VTONService()
 
@app.post("/api/v1/try-on", response_model=TryOnResponse)
async def try_on(request: TryOnRequest):
    """バーチャル試着 API エンドポイント"""
    return await vton_service.process_try_on(request)
 
@app.post("/api/v1/upload-photo")
async def upload_photo(file: UploadFile = File(...)):
    """ユーザー写真のアップロード"""
    if file.content_type not in ["image/jpeg", "image/png"]:
        raise HTTPException(400, "JPEG または PNG のみ対応")
 
    image_id = str(uuid.uuid4())
    # S3 に保存
    return {"image_id": image_id, "status": "uploaded"}

// React コンポーネントでの統合例
 
interface TryOnResult {
  requestId: string;
  status: string;
  resultUrls: string[];
  processingTimeMs: number;
}
 
async function virtualTryOn(
  personImageId: string,
  garmentId: string,
  category: 'upperbody' | 'lowerbody' | 'dress' = 'upperbody'
): Promise<TryOnResult> {
  const response = await fetch('/api/v1/try-on', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      person_image_id: personImageId,
      garment_id: garmentId,
      category: category,
      guidance_scale: 2.0,
      num_samples: 1,
    }),
  });
 
  if (!response.ok) {
    throw new Error(`Try-on failed: ${response.statusText}`);
  }
 
  return response.json();
}
 
// UX パターン: プログレッシブ表示
// 1. ローディングスケルトン表示
// 2. 低解像度のプレビューを先に表示（512px）
// 3. 高解像度の結果に差し替え（1024px+）

# TensorRT による推論高速化
 
import tensorrt as trt
import numpy as np
 
class TRTOptimizedVTON:
    """TensorRT で最適化されたバーチャル試着モデル"""
 
    def __init__(self, engine_path: str):
        self.logger = trt.Logger(trt.Logger.WARNING)
        with open(engine_path, "rb") as f:
            self.engine = trt.Runtime(self.logger).deserialize_cuda_engine(f.read())
        self.context = self.engine.create_execution_context()
 
    @staticmethod
    def convert_to_trt(
        onnx_path: str,
        output_path: str,
        fp16: bool = True,
        max_batch: int = 4,
    ):
        """ONNX モデルを TensorRT エンジンに変換"""
        builder = trt.Builder(trt.Logger(trt.Logger.WARNING))
        network = builder.create_network(
            1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
        )
        parser = trt.OnnxParser(network, trt.Logger(trt.Logger.WARNING))
 
        with open(onnx_path, "rb") as f:
            parser.parse(f.read())
 
        config = builder.create_builder_config()
        config.max_workspace_size = 4 << 30  # 4GB
 
        if fp16:
            config.set_flag(trt.BuilderFlag.FP16)
 
        # ダイナミックバッチサイズ
        profile = builder.create_optimization_profile()
        input_shape = network.get_input(0).shape
        profile.set_shape(
            network.get_input(0).name,
            min=(1, *input_shape[1:]),
            opt=(2, *input_shape[1:]),
            max=(max_batch, *input_shape[1:]),
        )
        config.add_optimization_profile(profile)
 
        engine = builder.build_engine(network, config)
        with open(output_path, "wb") as f:
            f.write(engine.serialize())
 
        print(f"TRT engine saved: {output_path}")
 
 
# 高速化の効果比較
# ┌──────────────┬──────────┬──────────┬──────────┐
# │ 手法          │ 推論時間  │ VRAM     │ 品質     │
# ├──────────────┼──────────┼──────────┼──────────┤
# │ PyTorch FP32 │ 3.5秒    │ 8GB      │ 最高     │
# │ PyTorch FP16 │ 1.8秒    │ 4GB      │ ほぼ同等  │
# │ ONNX Runtime │ 1.2秒    │ 4GB      │ ほぼ同等  │
# │ TensorRT FP16│ 0.6秒    │ 3GB      │ ほぼ同等  │
# │ TensorRT INT8│ 0.3秒    │ 2GB      │ やや低下  │
# └──────────────┴──────────┴──────────┴──────────┘

# Redis を使った試着結果のキャッシング
 
import hashlib
import redis
import json
 
class TryOnCache:
    """試着結果のキャッシュ管理"""
 
    def __init__(self, redis_url: str = "redis://localhost:6379"):
        self.redis = redis.from_url(redis_url)
        self.ttl = 3600 * 24  # 24時間
 
    def _generate_key(self, person_hash: str, garment_id: str, params: dict) -> str:
        """キャッシュキーの生成"""
        param_str = json.dumps(params, sort_keys=True)
        raw = f"{person_hash}:{garment_id}:{param_str}"
        return f"vton:{hashlib.sha256(raw.encode()).hexdigest()}"
 
    def get_cached_result(self, person_hash: str, garment_id: str, params: dict):
        """キャッシュから結果を取得"""
        key = self._generate_key(person_hash, garment_id, params)
        result = self.redis.get(key)
        if result:
            return json.loads(result)
        return None
 
    def cache_result(self, person_hash: str, garment_id: str, params: dict, result_urls: list):
        """結果をキャッシュに保存"""
        key = self._generate_key(person_hash, garment_id, params)
        self.redis.setex(key, self.ttl, json.dumps(result_urls))
 
    def get_cache_stats(self) -> dict:
        """キャッシュ統計"""
        info = self.redis.info("stats")
        return {
            "hits": info.get("keyspace_hits", 0),
            "misses": info.get("keyspace_misses", 0),
            "hit_rate": info.get("keyspace_hits", 0) /
                        max(info.get("keyspace_hits", 0) + info.get("keyspace_misses", 0), 1),
        }

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()

# 設計判断の記録テンプレート
class ArchitectureDecisionRecord:
    """ADR (Architecture Decision Record) の作成"""
 
    def __init__(self, title: str):
        self.title = title
        self.context = ""
        self.decision = ""
        self.consequences = []
        self.alternatives = []
 
    def set_context(self, context: str):
        """背景と課題の記述"""
        self.context = context
        return self
 
    def set_decision(self, decision: str):
        """決定内容の記述"""
        self.decision = decision
        return self
 
    def add_consequence(self, consequence: str, positive: bool = True):
        """結果の追加"""
        self.consequences.append({
            'description': consequence,
            'type': 'positive' if positive else 'negative'
        })
        return self
 
    def add_alternative(self, name: str, reason_rejected: str):
        """却下した代替案の追加"""
        self.alternatives.append({
            'name': name,
            'reason_rejected': reason_rejected
        })
        return self
 
    def to_markdown(self) -> str:
        """Markdown形式で出力"""
        md = f"# ADR: {self.title}\n\n"
        md += f"## 背景\n{self.context}\n\n"
        md += f"## 決定\n{self.decision}\n\n"
        md += "## 結果\n"
        for c in self.consequences:
            icon = "✅" if c['type'] == 'positive' else "⚠️"
            md += f"- {icon} {c['description']}\n"
        md += "\n## 却下した代替案\n"
        for a in self.alternatives:
            md += f"- **{a['name']}**: {a['reason_rejected']}\n"
        return md

# チーム間のAPI契約定義
from dataclasses import dataclass
from typing import List, Optional
from enum import Enum
 
class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"
 
@dataclass
class APIContract:
    """チーム間のAPI契約"""
    endpoint: str
    method: str
    owner_team: str
    consumers: List[str]
    sla_ms: int  # レスポンスタイムSLA
    priority: Priority
 
    def validate_sla(self, actual_ms: int) -> bool:
        """SLA準拠の確認"""
        return actual_ms <= self.sla_ms
 
    def to_openapi(self) -> dict:
        """OpenAPI形式で出力"""
        return {
            'path': self.endpoint,
            'method': self.method,
            'x-owner': self.owner_team,
            'x-consumers': self.consumers,
            'x-sla-ms': self.sla_ms
        }
 
# 使用例
contracts = [
    APIContract(
        endpoint="/api/v1/users",
        method="GET",
        owner_team="user-team",
        consumers=["order-team", "notification-team"],
        sla_ms=200,
        priority=Priority.HIGH
    ),
    APIContract(
        endpoint="/api/v1/orders",
        method="POST",
        owner_team="order-team",
        consumers=["payment-team", "inventory-team"],
        sla_ms=500,
        priority=Priority.CRITICAL
    )
]