# SRP違反: Userクラスが認証・永続化・通知すべてを担当
class User:
    def __init__(self, name: str, email: str, password: str):
        self.name = name
        self.email = email
        self.password = password
 
    def authenticate(self, password: str) -> bool:
        """認証ロジック（セキュリティチームが管理）"""
        return bcrypt.check(self.password, password)
 
    def save(self) -> None:
        """永続化ロジック（インフラチームが管理）"""
        db.execute("INSERT INTO users ...", self.name, self.email)
 
    def send_welcome_email(self) -> None:
        """通知ロジック（マーケティングチームが管理）"""
        smtp.send(self.email, "Welcome!", f"こんにちは {self.name}")
 
 
# SRP適用: 各責任を専用クラスに分離
class User:
    """ユーザーのドメインモデル（データ表現のみ）"""
    def __init__(self, name: str, email: str):
        self.name = name
        self.email = email
 
 
class AuthenticationService:
    """認証ロジックを担当（アクター: セキュリティチーム）"""
    def __init__(self, credential_store: "CredentialStore"):
        self.credential_store = credential_store
 
    def authenticate(self, user: User, password: str) -> bool:
        stored_hash = self.credential_store.get_hash(user.email)
        return bcrypt.check(stored_hash, password)
 
 
class UserRepository:
    """ユーザーの永続化を担当（アクター: インフラチーム）"""
    def __init__(self, db: "Database"):
        self.db = db
 
    def save(self, user: User) -> None:
        self.db.execute("INSERT INTO users ...", user.name, user.email)
 
    def find_by_email(self, email: str) -> User | None:
        row = self.db.query("SELECT * FROM users WHERE email = %s", email)
        return User(row['name'], row['email']) if row else None
 
 
class NotificationService:
    """通知送信を担当（アクター: マーケティングチーム）"""
    def __init__(self, mailer: "Mailer"):
        self.mailer = mailer
 
    def send_welcome(self, user: User) -> None:
        self.mailer.send(user.email, "Welcome!", f"こんにちは {user.name}")

# SRP違反: 1つのクラスがパース・フィルタ・集計・出力を担当
class LogAnalyzer:
    def analyze(self, log_file: str) -> None:
        # パース
        entries = []
        with open(log_file) as f:
            for line in f:
                parts = line.strip().split(' ')
                entries.append({
                    'timestamp': parts[0],
                    'level': parts[1],
                    'message': ' '.join(parts[2:])
                })
 
        # フィルタ
        errors = [e for e in entries if e['level'] == 'ERROR']
 
        # 集計
        counts = {}
        for error in errors:
            msg = error['message'][:50]
            counts[msg] = counts.get(msg, 0) + 1
 
        # 出力
        for msg, count in sorted(counts.items(), key=lambda x: -x[1]):
            print(f"{count:5d} | {msg}")
 
 
# SRP適用: 各責任を分離
from dataclasses import dataclass
from typing import Iterator
 
@dataclass
class LogEntry:
    timestamp: str
    level: str
    message: str
 
class LogParser:
    """ログファイルのパースを担当"""
    def parse(self, log_file: str) -> list[LogEntry]:
        entries = []
        with open(log_file) as f:
            for line in f:
                entries.append(self._parse_line(line))
        return entries
 
    def _parse_line(self, line: str) -> LogEntry:
        parts = line.strip().split(' ', 2)
        return LogEntry(
            timestamp=parts[0],
            level=parts[1],
            message=parts[2] if len(parts) > 2 else ''
        )
 
class LogFilter:
    """ログエントリのフィルタリングを担当"""
    def filter_by_level(
        self, entries: list[LogEntry], level: str
    ) -> list[LogEntry]:
        return [e for e in entries if e.level == level]
 
class LogAggregator:
    """ログの集計を担当"""
    def count_by_message(
        self, entries: list[LogEntry], prefix_length: int = 50
    ) -> dict[str, int]:
        counts: dict[str, int] = {}
        for entry in entries:
            key = entry.message[:prefix_length]
            counts[key] = counts.get(key, 0) + 1
        return counts
 
class LogReporter:
    """集計結果の出力を担当"""
    def print_summary(self, counts: dict[str, int]) -> None:
        for msg, count in sorted(counts.items(), key=lambda x: -x[1]):
            print(f"{count:5d} | {msg}")

// OCP違反: 新しい図形を追加するたびにこのクラスを修正する必要がある
class AreaCalculator {
  calculate(shape: any): number {
    if (shape.type === 'circle') {
      return Math.PI * shape.radius ** 2;
    } else if (shape.type === 'rectangle') {
      return shape.width * shape.height;
    } else if (shape.type === 'triangle') {
      return (shape.base * shape.height) / 2;
    }
    // 新しい図形を追加するたびに if 分岐が増える...
    throw new Error(`Unknown shape: ${shape.type}`);
  }
}
 
// OCP適用: 新しい図形はクラス追加のみで対応（既存コード変更不要）
interface Shape {
  area(): number;
  perimeter(): number;
}
 
class Circle implements Shape {
  constructor(private radius: number) {}
  area(): number {
    return Math.PI * this.radius ** 2;
  }
  perimeter(): number {
    return 2 * Math.PI * this.radius;
  }
}
 
class Rectangle implements Shape {
  constructor(private width: number, private height: number) {}
  area(): number {
    return this.width * this.height;
  }
  perimeter(): number {
    return 2 * (this.width + this.height);
  }
}
 
// 新しい図形の追加: 既存コードを一切変更しない
class Pentagon implements Shape {
  constructor(private side: number) {}
  area(): number {
    return (Math.sqrt(5 * (5 + 2 * Math.sqrt(5))) / 4) * this.side ** 2;
  }
  perimeter(): number {
    return 5 * this.side;
  }
}
 
class AreaCalculator {
  calculate(shape: Shape): number {
    return shape.area();  // 多態性で処理を委譲
  }
 
  calculateTotal(shapes: Shape[]): number {
    return shapes.reduce((total, shape) => total + shape.area(), 0);
  }
}

from abc import ABC, abstractmethod
from dataclasses import dataclass
from decimal import Decimal
 
@dataclass
class Order:
    subtotal: Decimal
    customer_type: str
    item_count: int
 
# OCP違反: 新しい割引ルールの追加には既存コードの修正が必要
class DiscountCalculatorBad:
    def calculate(self, order: Order) -> Decimal:
        if order.customer_type == 'vip':
            return order.subtotal * Decimal('0.20')
        elif order.customer_type == 'regular' and order.item_count >= 10:
            return order.subtotal * Decimal('0.10')
        elif order.customer_type == 'employee':
            return order.subtotal * Decimal('0.30')
        # 新しい割引ルール追加のたびに elif が増える
        return Decimal('0')
 
 
# OCP適用: ストラテジーパターンで拡張可能に
class DiscountStrategy(ABC):
    @abstractmethod
    def calculate(self, order: Order) -> Decimal:
        """割引額を計算する"""
        pass
 
    @abstractmethod
    def is_applicable(self, order: Order) -> bool:
        """この割引が適用可能か判定する"""
        pass
 
class VipDiscount(DiscountStrategy):
    def calculate(self, order: Order) -> Decimal:
        return order.subtotal * Decimal('0.20')
 
    def is_applicable(self, order: Order) -> bool:
        return order.customer_type == 'vip'
 
class BulkDiscount(DiscountStrategy):
    MIN_ITEMS = 10
    def calculate(self, order: Order) -> Decimal:
        return order.subtotal * Decimal('0.10')
 
    def is_applicable(self, order: Order) -> bool:
        return order.item_count >= self.MIN_ITEMS
 
class EmployeeDiscount(DiscountStrategy):
    def calculate(self, order: Order) -> Decimal:
        return order.subtotal * Decimal('0.30')
 
    def is_applicable(self, order: Order) -> bool:
        return order.customer_type == 'employee'
 
# 新しい割引を追加: SeasonalDiscount クラスを作るだけ
class SeasonalDiscount(DiscountStrategy):
    """季節限定割引（新規追加でも既存コード変更なし）"""
    def calculate(self, order: Order) -> Decimal:
        return order.subtotal * Decimal('0.15')
 
    def is_applicable(self, order: Order) -> bool:
        from datetime import date
        month = date.today().month
        return month in (7, 8, 12)  # 夏と年末
 
class DiscountCalculator:
    """割引計算のオーケストレーター（修正に閉じている）"""
    def __init__(self, strategies: list[DiscountStrategy]):
        self.strategies = strategies
 
    def calculate_best_discount(self, order: Order) -> Decimal:
        applicable = [
            s.calculate(order)
            for s in self.strategies
            if s.is_applicable(order)
        ]
        return max(applicable, default=Decimal('0'))
 
# 使用例: 戦略を注入
calculator = DiscountCalculator([
    VipDiscount(),
    BulkDiscount(),
    EmployeeDiscount(),
    SeasonalDiscount(),  # 新しい戦略を追加するだけ
])

class Rectangle:
    def __init__(self, width: int, height: int):
        self._width = width
        self._height = height
 
    @property
    def width(self) -> int:
        return self._width
 
    @width.setter
    def width(self, value: int):
        self._width = value
 
    @property
    def height(self) -> int:
        return self._height
 
    @height.setter
    def height(self, value: int):
        self._height = value
 
    def area(self) -> int:
        return self._width * self._height
 
 
# LSP違反: Square は Rectangle の契約を破る
class Square(Rectangle):
    def __init__(self, side: int):
        super().__init__(side, side)
 
    @Rectangle.width.setter
    def width(self, value: int):
        self._width = value
        self._height = value  # 幅を変えると高さも変わる！
 
    @Rectangle.height.setter
    def height(self, value: int):
        self._width = value
        self._height = value
 
 
# この関数は Rectangle の契約を前提としている
def test_area(rect: Rectangle):
    rect.width = 5
    rect.height = 4
    assert rect.area() == 20  # Square だと失敗！(5*5=25)
 
 
# LSP準拠: 共通インターフェースで設計
from abc import ABC, abstractmethod
 
class Shape(ABC):
    @abstractmethod
    def area(self) -> int:
        pass
 
    @abstractmethod
    def perimeter(self) -> int:
        pass
 
class Rectangle(Shape):
    def __init__(self, width: int, height: int):
        self._width = width
        self._height = height
 
    def area(self) -> int:
        return self._width * self._height
 
    def perimeter(self) -> int:
        return 2 * (self._width + self._height)
 
class Square(Shape):
    def __init__(self, side: int):
        self._side = side
 
    def area(self) -> int:
        return self._side ** 2
 
    def perimeter(self) -> int:
        return 4 * self._side

// LSP違反: ReadOnlyList が List の「追加可能」という契約を破る
class ReadOnlyList<T> extends ArrayList<T> {
    @Override
    public boolean add(T element) {
        throw new UnsupportedOperationException("読み取り専用です");
    }
 
    @Override
    public T remove(int index) {
        throw new UnsupportedOperationException("読み取り専用です");
    }
}
 
// List を受け取る関数は add() が使えることを前提としている
void addDefaultItems(List<String> list) {
    list.add("default1");  // ReadOnlyList だと実行時エラー！
    list.add("default2");
}
 
 
// LSP準拠: 適切なインターフェースを使い分ける
// Java の標準ライブラリは既にこの区別を提供している
void readItems(Iterable<String> items) {
    // 読み取りのみ → Iterable で十分
    for (String item : items) {
        System.out.println(item);
    }
}
 
void modifyItems(List<String> items) {
    // 変更が必要 → List を要求（ReadOnlyListは渡されない）
    items.add("new item");
}

// ISP違反: 巨大なインターフェース
interface Worker {
    void work();
    void eat();
    void sleep();
    void attendMeeting();
    void writeReport();
}
 
// ロボットはeat/sleepできないが、実装を強制される
class Robot implements Worker {
    public void work() { /* 作業する */ }
    public void eat() { throw new UnsupportedOperationException(); }   // LSP違反も!
    public void sleep() { throw new UnsupportedOperationException(); }
    public void attendMeeting() { throw new UnsupportedOperationException(); }
    public void writeReport() { throw new UnsupportedOperationException(); }
}
 
 
// ISP適用: 役割ごとにインターフェースを分離
interface Workable {
    void work();
}
 
interface Feedable {
    void eat();
}
 
interface Restable {
    void sleep();
}
 
interface Communicable {
    void attendMeeting();
    void writeReport();
}
 
// 人間: すべてを実装
class HumanWorker implements Workable, Feedable, Restable, Communicable {
    public void work() { /* 作業する */ }
    public void eat() { /* 食事する */ }
    public void sleep() { /* 睡眠する */ }
    public void attendMeeting() { /* 会議に出る */ }
    public void writeReport() { /* レポートを書く */ }
}
 
// ロボット: 必要なものだけ実装
class RobotWorker implements Workable {
    public void work() { /* 作業する */ }
}
 
// AIアシスタント: 作業とコミュニケーション
class AiAssistant implements Workable, Communicable {
    public void work() { /* 作業する */ }
    public void attendMeeting() { /* 議事録を取る */ }
    public void writeReport() { /* レポートを生成する */ }
}

// ISP違反: 全CRUD操作を1つのインターフェースに
interface Repository<T> {
  findById(id: string): Promise<T | null>;
  findAll(): Promise<T[]>;
  save(entity: T): Promise<void>;
  update(entity: T): Promise<void>;
  delete(id: string): Promise<void>;
  bulkInsert(entities: T[]): Promise<void>;
  executeRawQuery(sql: string): Promise<any>;
}
 
// 読み取り専用のレポートサービスでも全メソッドが見える
class ReportService {
  constructor(private repo: Repository<Order>) {}
  // save, delete, executeRawQuery は使わないのに依存している
}
 
 
// ISP適用: 用途別にインターフェースを分離
interface Readable<T> {
  findById(id: string): Promise<T | null>;
  findAll(): Promise<T[]>;
}
 
interface Writable<T> {
  save(entity: T): Promise<void>;
  update(entity: T): Promise<void>;
}
 
interface Deletable {
  delete(id: string): Promise<void>;
}
 
interface BulkOperable<T> {
  bulkInsert(entities: T[]): Promise<void>;
}
 
// 完全なCRUDリポジトリ
interface CrudRepository<T>
  extends Readable<T>, Writable<T>, Deletable {}
 
// レポートサービスは読み取り専用インターフェースのみに依存
class ReportService {
  constructor(private repo: Readable<Order>) {}
 
  async generateMonthlyReport(): Promise<Report> {
    const orders = await this.repo.findAll();
    // ... レポート生成ロジック
  }
}
 
// 管理画面は全機能を利用
class AdminService {
  constructor(private repo: CrudRepository<Order>) {}
 
  async deleteOrder(id: string): Promise<void> {
    await this.repo.delete(id);
  }
}

# DIP違反: 上位モジュールが具象クラスに直接依存
class OrderService:
    def __init__(self):
        self.repository = MySQLOrderRepository()  # 具象への直接依存
        self.notifier = EmailNotifier()            # 具象への直接依存
        self.logger = FileLogger()                 # 具象への直接依存
 
    def place_order(self, order: "Order") -> None:
        self.repository.save(order)
        self.notifier.notify(order.customer, "注文を受け付けました")
        self.logger.log(f"注文 {order.id} を処理しました")
 
 
# DIP適用: 抽象（インターフェース）に依存
from abc import ABC, abstractmethod
 
class OrderRepository(ABC):
    @abstractmethod
    def save(self, order: "Order") -> None:
        pass
 
    @abstractmethod
    def find_by_id(self, order_id: str) -> "Order | None":
        pass
 
class Notifier(ABC):
    @abstractmethod
    def notify(self, recipient: str, message: str) -> None:
        pass
 
class Logger(ABC):
    @abstractmethod
    def log(self, message: str) -> None:
        pass
 
 
class OrderService:
    """上位モジュール: 抽象にのみ依存"""
    def __init__(
        self,
        repository: OrderRepository,
        notifier: Notifier,
        logger: Logger
    ):
        self.repository = repository
        self.notifier = notifier
        self.logger = logger
 
    def place_order(self, order: "Order") -> None:
        self.repository.save(order)
        self.notifier.notify(order.customer, "注文を受け付けました")
        self.logger.log(f"注文 {order.id} を処理しました")
 
 
# 下位モジュール: 抽象を実装
class PostgreSQLOrderRepository(OrderRepository):
    def __init__(self, connection_string: str):
        self.connection_string = connection_string
 
    def save(self, order: "Order") -> None:
        # PostgreSQL固有の実装
        pass
 
    def find_by_id(self, order_id: str) -> "Order | None":
        pass
 
class SlackNotifier(Notifier):
    def __init__(self, webhook_url: str):
        self.webhook_url = webhook_url
 
    def notify(self, recipient: str, message: str) -> None:
        # Slack API を使った通知
        pass
 
class CloudWatchLogger(Logger):
    def log(self, message: str) -> None:
        # AWS CloudWatch への送信
        pass
 
 
# 組み立て（Composition Root）
service = OrderService(
    repository=PostgreSQLOrderRepository("postgresql://..."),
    notifier=SlackNotifier("https://hooks.slack.com/..."),
    logger=CloudWatchLogger()
)
 
# テスト時: モックを注入
class MockRepository(OrderRepository):
    def __init__(self):
        self.saved_orders = []
 
    def save(self, order):
        self.saved_orders.append(order)
 
    def find_by_id(self, order_id):
        return next((o for o in self.saved_orders if o.id == order_id), None)
 
test_service = OrderService(
    repository=MockRepository(),
    notifier=MockNotifier(),
    logger=MockLogger()
)

// DIP はアーキテクチャ原則、DI はそれを実現する実装手法
 
// 1. コンストラクタインジェクション（最も推奨）
class UserService {
  constructor(
    private readonly repository: UserRepository,
    private readonly hasher: PasswordHasher,
    private readonly mailer: Mailer
  ) {}
 
  async register(email: string, password: string): Promise<User> {
    const hashedPassword = await this.hasher.hash(password);
    const user = new User(email, hashedPassword);
    await this.repository.save(user);
    await this.mailer.sendWelcome(email);
    return user;
  }
}
 
// 2. セッターインジェクション（オプショナルな依存に）
class ReportGenerator {
  private formatter: ReportFormatter = new DefaultFormatter();
 
  setFormatter(formatter: ReportFormatter): void {
    this.formatter = formatter;
  }
}
 
// 3. メソッドインジェクション（呼び出し毎に異なる依存）
class DataProcessor {
  process(data: RawData, transformer: DataTransformer): ProcessedData {
    return transformer.transform(data);
  }
}

# SOLID原則の組み合わせ例: 通知サービス
 
# SRP: 通知送信の責任のみ
# OCP: 新しい通知チャネルはクラス追加で対応
# LSP: すべてのNotifierはsendメソッドの契約を守る
# ISP: 同期/非同期を分離
# DIP: 抽象に依存
 
from abc import ABC, abstractmethod
 
# ISP: 同期通知と非同期通知を分離
class SyncNotifier(ABC):
    @abstractmethod
    def send(self, recipient: str, message: str) -> bool:
        """同期的にメッセージを送信し、成否を返す"""
        pass
 
class AsyncNotifier(ABC):
    @abstractmethod
    async def send(self, recipient: str, message: str) -> str:
        """非同期でメッセージを送信し、ジョブIDを返す"""
        pass
 
# LSP: 各実装はインターフェースの契約を完全に守る
class EmailNotifier(SyncNotifier):
    """SRP: メール送信のみを担当"""
    def __init__(self, smtp_config: dict):
        self.smtp = SmtpClient(smtp_config)
 
    def send(self, recipient: str, message: str) -> bool:
        try:
            self.smtp.send_mail(recipient, message)
            return True
        except SmtpError:
            return False
 
class SlackNotifier(AsyncNotifier):
    """SRP: Slack通知のみを担当"""
    def __init__(self, webhook_url: str):
        self.webhook_url = webhook_url
 
    async def send(self, recipient: str, message: str) -> str:
        response = await http_post(self.webhook_url, {"text": message})
        return response["job_id"]
 
# OCP: 新しい通知チャネル追加時、既存コードを変更しない
class SmsNotifier(SyncNotifier):
    """新規追加: SMS通知"""
    def __init__(self, api_key: str):
        self.sms_client = SmsClient(api_key)
 
    def send(self, recipient: str, message: str) -> bool:
        return self.sms_client.send_sms(recipient, message)
 
# DIP: NotificationService は抽象にのみ依存
class NotificationService:
    def __init__(self, notifiers: list[SyncNotifier]):
        self.notifiers = notifiers
 
    def notify_all(self, recipient: str, message: str) -> dict[str, bool]:
        results = {}
        for notifier in self.notifiers:
            name = type(notifier).__name__
            results[name] = notifier.send(recipient, message)
        return results

# 関数型でのOCP: 高階関数による拡張
from typing import Any, Callable
 
# ソート戦略を関数として注入（OCP + DIP）
def sort_users(
    users: list[dict],
    key_fn: Callable[[dict], Any] = lambda u: u['name']
) -> list[dict]:
    return sorted(users, key=key_fn)
 
# 新しいソート基準の追加: 既存コード変更なし
by_age = lambda u: u['age']
by_score_desc = lambda u: -u['score']
 
sort_users(users, key_fn=by_age)
sort_users(users, key_fn=by_score_desc)

# NG: 1つのクラスに全責任を詰め込む
class Application:
    def authenticate_user(self): ...
    def process_payment(self): ...
    def generate_report(self): ...
    def send_notification(self): ...
    def validate_input(self): ...
    def manage_cache(self): ...
    def handle_logging(self): ...
    # 1000行以上のメソッドが続く...
 
# OK: 責任ごとにクラスを分割
class AuthService: ...
class PaymentService: ...
class ReportService: ...
class NotificationService: ...
class InputValidator: ...
class CacheManager: ...
class Logger: ...

// NG: 1メソッドのためにインターフェース + 実装 + ファクトリ + DI設定
interface StringFormatter { String format(String s); }
class UpperCaseFormatter implements StringFormatter {
    public String format(String s) { return s.toUpperCase(); }
}
class StringFormatterFactory {
    public StringFormatter create(String type) { ... }
}
class StringFormatterConfig {
    @Bean
    public StringFormatter formatter() { return new UpperCaseFormatter(); }
}
// 実際にはただの s.toUpperCase() で十分
 
// OK: 必要性が生じたら抽象化する
String formatted = input.toUpperCase();

# NG: インターフェースがDBの詳細を漏洩
class UserRepository(ABC):
    @abstractmethod
    def find_by_sql(self, sql: str) -> list[User]:
        """SQLクエリでユーザーを検索する"""
        pass  # SQL前提 → RDB以外の実装で困る
 
    @abstractmethod
    def set_connection_pool_size(self, size: int) -> None:
        """接続プールサイズを設定する"""
        pass  # 接続プール前提 → インメモリ実装で無意味
 
# OK: ドメインの言葉でインターフェースを定義
class UserRepository(ABC):
    @abstractmethod
    def find_by_email(self, email: str) -> User | None:
        """メールアドレスでユーザーを検索する"""
        pass
 
    @abstractmethod
    def find_active_users(self, since: datetime) -> list[User]:
        """指定日以降にアクティブなユーザーを検索する"""
        pass

class ReportManager:
    def __init__(self, db_connection):
        self.db = db_connection
 
    def fetch_sales_data(self, start_date, end_date):
        query = f"SELECT * FROM sales WHERE date BETWEEN '{start_date}' AND '{end_date}'"
        return self.db.execute(query)
 
    def calculate_totals(self, sales_data):
        total = sum(item['amount'] for item in sales_data)
        tax = total * 0.10
        return {'subtotal': total, 'tax': tax, 'total': total + tax}
 
    def format_as_html(self, report_data):
        html = "<html><body>"
        html += f"<h1>売上レポート</h1>"
        html += f"<p>合計: {report_data['total']}円</p>"
        html += "</body></html>"
        return html
 
    def send_email(self, recipient, html_content):
        import smtplib
        server = smtplib.SMTP('localhost')
        server.sendmail('reports@company.com', recipient, html_content)
        server.quit()
 
    def generate_and_send(self, start_date, end_date, recipient):
        data = self.fetch_sales_data(start_date, end_date)
        totals = self.calculate_totals(data)
        html = self.format_as_html(totals)
        self.send_email(recipient, html)

class SalesDataRepository:
    def __init__(self, db):
        self.db = db
 
    def fetch(self, start_date: str, end_date: str) -> list[dict]:
        return self.db.execute(
            "SELECT * FROM sales WHERE date BETWEEN %s AND %s",
            (start_date, end_date)
        )
 
class SalesCalculator:
    TAX_RATE = Decimal('0.10')
 
    def calculate_totals(self, sales_data: list[dict]) -> dict:
        subtotal = sum(Decimal(str(item['amount'])) for item in sales_data)
        tax = subtotal * self.TAX_RATE
        return {'subtotal': subtotal, 'tax': tax, 'total': subtotal + tax}
 
class ReportFormatter(ABC):
    @abstractmethod
    def format(self, report_data: dict) -> str: ...
 
class HtmlReportFormatter(ReportFormatter):
    def format(self, report_data: dict) -> str:
        return f"""<html><body>
        <h1>売上レポート</h1>
        <p>合計: {report_data['total']}円</p>
        </body></html>"""
 
class EmailSender:
    def __init__(self, smtp_host: str, from_address: str):
        self.smtp_host = smtp_host
        self.from_address = from_address
 
    def send(self, recipient: str, content: str) -> None:
        # SMTP送信ロジック
        pass
 
class ReportService:
    def __init__(self, repo, calculator, formatter, sender):
        self.repo = repo
        self.calculator = calculator
        self.formatter = formatter
        self.sender = sender
 
    def generate_and_send(self, start_date, end_date, recipient):
        data = self.repo.fetch(start_date, end_date)
        totals = self.calculator.calculate_totals(data)
        content = self.formatter.format(totals)
        self.sender.send(recipient, content)

class PaymentProcessor:
    def process(self, payment_method: str, amount: float) -> bool:
        if payment_method == "credit_card":
            # クレジットカード決済ロジック
            return self._process_credit_card(amount)
        elif payment_method == "bank_transfer":
            # 銀行振込ロジック
            return self._process_bank_transfer(amount)
        elif payment_method == "paypal":
            # PayPalロジック
            return self._process_paypal(amount)
        else:
            raise ValueError(f"未対応の決済方法: {payment_method}")

from abc import ABC, abstractmethod
 
class PaymentMethod(ABC):
    @abstractmethod
    def process(self, amount: float) -> bool: ...
 
    @abstractmethod
    def name(self) -> str: ...
 
class CreditCardPayment(PaymentMethod):
    def process(self, amount: float) -> bool:
        # クレジットカード決済ロジック
        return True
    def name(self) -> str:
        return "credit_card"
 
class BankTransferPayment(PaymentMethod):
    def process(self, amount: float) -> bool:
        # 銀行振込ロジック
        return True
    def name(self) -> str:
        return "bank_transfer"
 
# 新しい決済方法の追加: 既存コード変更なし
class CryptoPayment(PaymentMethod):
    def process(self, amount: float) -> bool:
        # 暗号通貨決済ロジック
        return True
    def name(self) -> str:
        return "crypto"
 
class PaymentProcessor:
    def __init__(self):
        self._methods: dict[str, PaymentMethod] = {}
 
    def register(self, method: PaymentMethod) -> None:
        self._methods[method.name()] = method
 
    def process(self, method_name: str, amount: float) -> bool:
        if method_name not in self._methods:
            raise ValueError(f"未対応の決済方法: {method_name}")
        return self._methods[method_name].process(amount)