# DRY違反: 税計算ロジックが2箇所に存在
class InvoiceService:
    def calculate_total(self, subtotal: float) -> float:
        tax = subtotal * 0.10  # 消費税10%
        return subtotal + tax
 
class CartService:
    def calculate_total(self, subtotal: float) -> float:
        tax = subtotal * 0.10  # 消費税10% ← 同じ知識の重複！
        return subtotal + tax
 
 
# DRY適用: 税計算の知識を一元化
class TaxCalculator:
    """税計算の唯一の権威ある情報源"""
    TAX_RATE = 0.10
 
    @classmethod
    def calculate_tax(cls, amount: float) -> float:
        """税額を計算する"""
        return amount * cls.TAX_RATE
 
    @classmethod
    def calculate_total_with_tax(cls, subtotal: float) -> float:
        """税込み合計を計算する"""
        return subtotal + cls.calculate_tax(subtotal)
 
 
class InvoiceService:
    def calculate_total(self, subtotal: float) -> float:
        return TaxCalculator.calculate_total_with_tax(subtotal)
 
class CartService:
    def calculate_total(self, subtotal: float) -> float:
        return TaxCalculator.calculate_total_with_tax(subtotal)

# これはDRY違反ではない！
# 見た目は似ているが、異なる「知識」を表現している
 
def validate_username(name: str) -> bool:
    """ユーザー名は3文字以上20文字以下（ユーザー名のビジネスルール）"""
    return 3 <= len(name) <= 20
 
def validate_product_name(name: str) -> bool:
    """商品名は3文字以上20文字以下（商品名のビジネスルール）"""
    return 3 <= len(name) <= 20
 
# 無理に共通化するとこうなる（悪い例）:
def validate_name_length(name: str, min_len: int = 3, max_len: int = 20) -> bool:
    return min_len <= len(name) <= max_len
 
# 問題: ユーザー名ルールが変わっても商品名ルールは変わらない
# 例: 「ユーザー名は5文字以上に変更」→ 商品名まで影響する
# これは「偶然の一致」であり、別の「知識」

// DRY違反: 同じ値がコードの各所に散在
class UserValidator {
  validate(email: string): boolean {
    return /^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$/.test(email);
  }
}
 
class RegistrationForm {
  isValidEmail(email: string): boolean {
    return /^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$/.test(email);
  }
}
 
// DRY適用: 正規表現を1箇所で定義
const EMAIL_PATTERN = /^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$/;
 
function isValidEmail(email: string): boolean {
  return EMAIL_PATTERN.test(email);
}
 
// すべての箇所がこの関数を使う
class UserValidator {
  validate(email: string): boolean {
    return isValidEmail(email);
  }
}

from abc import ABC, abstractmethod
from datetime import datetime
 
# DRY違反: レポート生成の共通フローが各クラスに重複
class SalesReport:
    def generate(self, data):
        header = f"=== 売上レポート ===\n日付: {datetime.now()}\n"
        body = self._format_sales(data)
        footer = f"\n--- 以上 ---\n"
        return header + body + footer
 
class InventoryReport:
    def generate(self, data):
        header = f"=== 在庫レポート ===\n日付: {datetime.now()}\n"
        body = self._format_inventory(data)
        footer = f"\n--- 以上 ---\n"
        return header + body + footer
 
 
# DRY適用: テンプレートメソッドパターン
class BaseReport(ABC):
    """レポート生成の共通フローを定義"""
 
    def generate(self, data) -> str:
        header = self._build_header()
        body = self._build_body(data)
        footer = self._build_footer()
        return header + body + footer
 
    def _build_header(self) -> str:
        return f"=== {self.title} ===\n日付: {datetime.now()}\n"
 
    def _build_footer(self) -> str:
        return f"\n--- 以上 ---\n"
 
    @property
    @abstractmethod
    def title(self) -> str:
        pass
 
    @abstractmethod
    def _build_body(self, data) -> str:
        pass
 
class SalesReport(BaseReport):
    @property
    def title(self) -> str:
        return "売上レポート"
 
    def _build_body(self, data) -> str:
        return "\n".join(f"  {item['name']}: {item['amount']}円" for item in data)
 
class InventoryReport(BaseReport):
    @property
    def title(self) -> str:
        return "在庫レポート"
 
    def _build_body(self, data) -> str:
        return "\n".join(f"  {item['name']}: {item['stock']}個" for item in data)

// KISS違反: 過度に複雑なバリデーション
class UserValidator {
  constructor() {
    this.validationChain = new ValidationChainBuilder()
      .addValidator(new NotNullValidator())
      .addValidator(new StringLengthValidator(1, 100))
      .addValidator(new RegexValidator(/^[a-zA-Z0-9_]+$/))
      .addValidator(new BlacklistValidator(BANNED_WORDS))
      .setErrorHandler(new ValidationErrorAggregator())
      .setLocalizationProvider(new I18nValidationMessages('ja'))
      .build();
  }
 
  validate(username) {
    return this.validationChain.execute(
      new ValidationContext(username, 'username')
    );
  }
}
 
// KISS適用: シンプルで十分
function validateUsername(username) {
  if (!username || username.length === 0) {
    return { valid: false, error: 'ユーザー名は必須です' };
  }
  if (username.length > 100) {
    return { valid: false, error: 'ユーザー名は100文字以内です' };
  }
  if (!/^[a-zA-Z0-9_]+$/.test(username)) {
    return { valid: false, error: '英数字とアンダースコアのみ使用できます' };
  }
  return { valid: true, error: null };
}

# KISS違反: 過度にジェネリックな変換パイプライン
class DataTransformPipeline:
    def __init__(self):
        self.transformers = []
 
    def add_transformer(self, transformer):
        self.transformers.append(transformer)
        return self
 
    def execute(self, data):
        result = data
        for transformer in self.transformers:
            result = transformer.transform(result)
        return result
 
pipeline = DataTransformPipeline()
pipeline.add_transformer(StripWhitespaceTransformer())
pipeline.add_transformer(LowercaseTransformer())
pipeline.add_transformer(RemoveSpecialCharsTransformer())
result = pipeline.execute(user_input)
 
 
# KISS適用: 直接的で明快
def normalize_input(text: str) -> str:
    """入力テキストを正規化する"""
    return text.strip().lower().replace('-', '').replace('.', '')

# KISS違反: 多層の抽象化を持つ設定管理
class ConfigurationManager:
    def __init__(self):
        self._providers = []
        self._cache = {}
        self._observers = []
        self._encryption_service = EncryptionService()
 
    def register_provider(self, provider):
        self._providers.append(provider)
 
    def get(self, key: str, default=None):
        if key in self._cache:
            return self._cache[key]
        for provider in reversed(self._providers):
            value = provider.get(key)
            if value is not None:
                if self._is_encrypted(key):
                    value = self._encryption_service.decrypt(value)
                self._cache[key] = value
                self._notify_observers(key, value)
                return value
        return default
 
 
# KISS適用: 必要十分なシンプルさ
import os
from dataclasses import dataclass
 
@dataclass(frozen=True)
class AppConfig:
    """アプリケーション設定（イミュータブル）"""
    database_url: str
    api_key: str
    debug: bool = False
    max_connections: int = 10
 
    @classmethod
    def from_env(cls) -> "AppConfig":
        """環境変数から設定を読み込む"""
        return cls(
            database_url=os.environ["DATABASE_URL"],
            api_key=os.environ["API_KEY"],
            debug=os.environ.get("DEBUG", "false").lower() == "true",
            max_connections=int(os.environ.get("MAX_CONNECTIONS", "10")),
        )

// YAGNI違反: 現時点で不要な拡張ポイントを大量に用意
interface LogTransport {
  send(entry: LogEntry): Promise<void>;
}
interface LogFormatter {
  format(entry: LogEntry): string;
}
interface LogFilter {
  shouldLog(entry: LogEntry): boolean;
}
 
class Logger {
  private transports: LogTransport[] = [];
  private formatters: Map<string, LogFormatter> = new Map();
  private filters: LogFilter[] = [];
  private bufferSize: number;
  private flushInterval: number;
  private retryPolicy: RetryPolicy;
  private encryptionProvider?: EncryptionProvider;
  // 実際に使うのはコンソール出力だけなのに...
}
 
 
// YAGNI適用: 今必要なものだけ実装
enum LogLevel { DEBUG = 0, INFO = 1, WARN = 2, ERROR = 3 }
 
class Logger {
  constructor(private level: LogLevel = LogLevel.INFO) {}
 
  info(message: string): void {
    if (this.level <= LogLevel.INFO) {
      console.log(`[INFO] ${new Date().toISOString()} ${message}`);
    }
  }
 
  error(message: string, error?: Error): void {
    if (this.level <= LogLevel.ERROR) {
      console.error(`[ERROR] ${new Date().toISOString()} ${message}`, error);
    }
  }
 
  warn(message: string): void {
    if (this.level <= LogLevel.WARN) {
      console.warn(`[WARN] ${new Date().toISOString()} ${message}`);
    }
  }
  // ファイル出力が必要になったら、その時に拡張する
}

import json
from dataclasses import dataclass
 
# YAGNI違反: あらゆるフォーマットに先行対応
class ApiResponse:
    def __init__(self, data, status=200):
        self.data = data
        self.status = status
        self._formatters = {
            'json': JsonFormatter(),
            'xml': XmlFormatter(),
            'csv': CsvFormatter(),
            'yaml': YamlFormatter(),
            'msgpack': MsgpackFormatter(),
        }
 
    def to_format(self, format_type: str) -> bytes:
        return self._formatters[format_type].format(self.data)
 
 
# YAGNI適用: 今はJSONのみ
@dataclass
class ApiResponse:
    data: dict
    status: int = 200
 
    def to_json(self) -> str:
        return json.dumps({
            'status': self.status,
            'data': self.data
        }, ensure_ascii=False)
# XMLやCSVが必要になったらその時に追加する

# レイヤー間DRY違反: バリデーションルールが分散
 
# 改善: 単一の定義から各層のルールを生成
AGE_MIN = 0
AGE_MAX = 150
 
def validate_age(age: int) -> bool:
    return AGE_MIN <= age <= AGE_MAX
 
def get_age_schema() -> dict:
    """JSON Schemaとしてフロントエンドと共有"""
    return {
        "type": "integer",
        "minimum": AGE_MIN,
        "maximum": AGE_MAX
    }
 
def get_age_constraint_sql() -> str:
    """DB制約として共有"""
    return f"CHECK (age >= {AGE_MIN} AND age <= {AGE_MAX})"

# NG: 同じバリデーションロジックが微妙に異なるパターンで存在
def validate_email_frontend(email):
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
    return bool(re.match(pattern, email))
 
def validate_email_backend(email):
    pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
    return bool(re.match(pattern, email))  # 微妙に違う！
 
# OK: 単一の定義
EMAIL_PATTERN = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
 
def validate_email(email: str) -> bool:
    """メールアドレスの形式を検証する（唯一の正規表現定義）"""
    return bool(re.match(EMAIL_PATTERN, email))

// NG: 使われないフレームワークを先に作る
public interface DataExporter<T, F extends ExportFormat, C extends ExportConfig> {
    ExportResult<T> export(Collection<T> data, F format, C config);
    void registerPlugin(ExportPlugin<T> plugin);
    void setMiddleware(ExportMiddleware<T>... middlewares);
}
// 実際に必要なのは「CSVでユーザー一覧を出力する」だけ
 
// OK: 必要最小限
public class UserCsvExporter {
    public String export(List<User> users) {
        StringBuilder csv = new StringBuilder("name,email\n");
        for (User u : users) {
            csv.append(u.getName()).append(",").append(u.getEmail()).append("\n");
        }
        return csv.toString();
    }
}

# NG: 異なるコンテキストの偶然の類似を無理に共通化
class GenericProcessor:
    def process(self, type: str, data: dict) -> dict:
        if type == 'user_registration':
            validated = self._validate(data, USER_RULES)
            result = self._save(data, 'users')
            self._notify(data['email'], 'welcome')
        elif type == 'email_campaign':
            validated = self._validate(data, CAMPAIGN_RULES)
            result = self._save(data, 'campaigns')
            self._notify(data['recipients'], 'campaign')
        return result
 
# OK: 各コンテキストは独立
class UserRegistrationService:
    def register(self, user_data: dict) -> User:
        self.validator.validate(user_data)
        user = self.repository.save(user_data)
        self.mailer.send_welcome(user.email)
        return user
 
class EmailCampaignService:
    def launch(self, campaign_data: dict) -> Campaign:
        self.validator.validate(campaign_data)
        campaign = self.repository.save(campaign_data)
        self.mailer.send_campaign(campaign.recipients)
        return campaign

class OrderService:
    def calculate_domestic_shipping(self, weight: float) -> float:
        if weight <= 1.0:
            base = 500
        elif weight <= 5.0:
            base = 800
        elif weight <= 10.0:
            base = 1200
        else:
            base = 1200 + (weight - 10) * 100
        tax = base * 0.10
        return base + tax
 
    def calculate_express_shipping(self, weight: float) -> float:
        if weight <= 1.0:
            base = 500
        elif weight <= 5.0:
            base = 800
        elif weight <= 10.0:
            base = 1200
        else:
            base = 1200 + (weight - 10) * 100
        express_surcharge = base * 0.50
        base = base + express_surcharge
        tax = base * 0.10
        return base + tax

TAX_RATE = 0.10
EXPRESS_SURCHARGE_RATE = 0.50
 
def _calculate_base_shipping(weight: float) -> float:
    """重量に基づく基本送料を計算する"""
    if weight <= 1.0:
        return 500.0
    elif weight <= 5.0:
        return 800.0
    elif weight <= 10.0:
        return 1200.0
    else:
        return 1200.0 + (weight - 10.0) * 100.0
 
def _apply_tax(amount: float) -> float:
    return amount * (1 + TAX_RATE)
 
class OrderService:
    def calculate_domestic_shipping(self, weight: float) -> float:
        base = _calculate_base_shipping(weight)
        return _apply_tax(base)
 
    def calculate_express_shipping(self, weight: float) -> float:
        base = _calculate_base_shipping(weight)
        base_with_surcharge = base * (1 + EXPRESS_SURCHARGE_RATE)
        return _apply_tax(base_with_surcharge)

def format_entity(entity: dict, entity_type: str) -> str:
    template = TEMPLATES[entity_type]
    fields = FIELD_MAPPINGS[entity_type]
    result = template['header']
    for field in fields:
        result += f"  {field['label']}: {entity.get(field['key'], 'N/A')}\n"
    result += template['footer']
    return result

def format_user(user: dict) -> str:
    return f"名前: {user.get('name', 'N/A')}\nメール: {user.get('email', 'N/A')}"
 
def format_product(product: dict) -> str:
    return f"商品名: {product.get('name', 'N/A')}\n価格: {product.get('price', 'N/A')}円"

from dataclasses import dataclass
 
@dataclass
class SearchQuery:
    """検索パラメータ（現在は名前のみ、将来フィールド追加可能）"""
    name: str
 
class ProductRepository:
    def search(self, query: SearchQuery) -> list:
        return self.db.query(
            "SELECT * FROM products WHERE name LIKE %s",
            (f"%{query.name}%",)
        )
 
class ProductSearchService:
    def __init__(self, repository: ProductRepository):
        self.repository = repository
 
    def search(self, name: str) -> list:
        query = SearchQuery(name=name)
        return self.repository.search(query)

# デバッグ用ユーティリティ
import logging
import traceback
from functools import wraps
 
# ロガーの設定
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s [%(levelname)s] %(name)s: %(message)s'
)
logger = logging.getLogger(__name__)
 
def debug_decorator(func):
    """関数の入出力をログ出力するデコレータ"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        logger.debug(f"呼び出し: {func.__name__}(args={args}, kwargs={kwargs})")
        try:
            result = func(*args, **kwargs)
            logger.debug(f"戻り値: {func.__name__} -> {result}")
            return result
        except Exception as e:
            logger.error(f"例外発生: {func.__name__}: {e}")
            logger.error(traceback.format_exc())
            raise
    return wrapper
 
@debug_decorator
def process_data(items):
    """データ処理（デバッグ対象）"""
    if not items:
        raise ValueError("空のデータ")
    return [item * 2 for item in items]

# 設計判断の記録テンプレート
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
    )
]

# セキュアコーディング例
import hashlib
import secrets
import hmac
from typing import Optional
 
class SecurityUtils:
    """セキュリティユーティリティ"""
 
    @staticmethod
    def generate_token(length: int = 32) -> str:
        """暗号学的に安全なトークン生成"""
        return secrets.token_urlsafe(length)
 
    @staticmethod
    def hash_password(password: str, salt: Optional[str] = None) -> tuple:
        """パスワードのハッシュ化"""
        if salt is None:
            salt = secrets.token_hex(16)
        hashed = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode('utf-8'),
            salt.encode('utf-8'),
            iterations=100000
        )
        return hashed.hex(), salt
 
    @staticmethod
    def verify_password(password: str, hashed: str, salt: str) -> bool:
        """パスワードの検証"""
        new_hash, _ = SecurityUtils.hash_password(password, salt)
        return hmac.compare_digest(new_hash, hashed)
 
    @staticmethod
    def sanitize_input(value: str) -> str:
        """入力値のサニタイズ"""
        dangerous_chars = ['<', '>', '"', "'", '&', '\\']
        result = value
        for char in dangerous_chars:
            result = result.replace(char, '')
        return result.strip()
 
# 使用例
token = SecurityUtils.generate_token()
hashed, salt = SecurityUtils.hash_password("my_password")
is_valid = SecurityUtils.verify_password("my_password", hashed, salt)

# マイグレーションスクリプトのテンプレート
import json
import logging
from pathlib import Path
from datetime import datetime
from typing import List, Dict, Callable
 
logger = logging.getLogger(__name__)
 
class MigrationRunner:
    """段階的マイグレーション実行エンジン"""
 
    def __init__(self, migration_dir: str):
        self.migration_dir = Path(migration_dir)
        self.migrations: List[Dict] = []
        self.completed: List[str] = []
 
    def register(self, version: str, description: str,
                 up: Callable, down: Callable):
        """マイグレーションの登録"""
        self.migrations.append({
            'version': version,
            'description': description,
            'up': up,
            'down': down,
            'registered_at': datetime.now().isoformat()
        })
 
    def run_up(self, target_version: str = None):
        """マイグレーションの実行（アップグレード）"""
        for migration in self.migrations:
            if migration['version'] in self.completed:
                continue
            logger.info(f"実行中: {migration['version']} - "
                       f"{migration['description']}")
            try:
                migration['up']()
                self.completed.append(migration['version'])
                logger.info(f"完了: {migration['version']}")
            except Exception as e:
                logger.error(f"失敗: {migration['version']}: {e}")
                raise
            if target_version and migration['version'] == target_version:
                break
 
    def run_down(self, target_version: str):
        """マイグレーションのロールバック"""
        for migration in reversed(self.migrations):
            if migration['version'] not in self.completed:
                continue
            if migration['version'] == target_version:
                break
            logger.info(f"ロールバック: {migration['version']}")
            migration['down']()
            self.completed.remove(migration['version'])
 
    def status(self) -> Dict:
        """マイグレーション状態の確認"""
        return {
            'total': len(self.migrations),
            'completed': len(self.completed),
            'pending': len(self.migrations) - len(self.completed),
            'versions': {
                m['version']: 'completed'
                if m['version'] in self.completed else 'pending'
                for m in self.migrations
            }
        }