Шаблонный метод

from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass, field


@dataclass
class ParseResult:
    title: str = ""
    body: list[str] = field(default_factory=list)
    metadata: dict = field(default_factory=dict)
    format: str = ""


class DocumentParser(ABC):
    def parse(self, content: str) -> ParseResult:
        """Шаблонный метод — определяет скелет алгоритма."""
        self.before_parse(content)
        result = ParseResult(format=self.format_name)
        raw = self.open_document(content)
        result.title = self.parse_title(raw)
        result.body = self.parse_body(raw)
        result.metadata = self.extract_metadata(raw)
        self.close_document(raw)
        return self.finalize(result)

    # Хук — подклассы могут переопределить, но не обязаны
    def before_parse(self, content: str) -> None:
        pass

    # Шаги с реализацией по умолчанию
    def open_document(self, content: str) -> str:
        print(f"[{self.format_name}] Открытие документа")
        return content

    def close_document(self, raw: str) -> None:
        print(f"[{self.format_name}] Закрытие документа")

    def finalize(self, result: ParseResult) -> ParseResult:
        print(f"[{self.format_name}] Парсинг завершён: '{result.title}'")
        return result

    # Абстрактные шаги — обязательны для реализации
    @property
    @abstractmethod
    def format_name(self) -> str: ...

    @abstractmethod
    def parse_title(self, raw: str) -> str: ...

    @abstractmethod
    def parse_body(self, raw: str) -> list[str]: ...

    @abstractmethod
    def extract_metadata(self, raw: str) -> dict: ...


class CsvParser(DocumentParser):
    @property
    def format_name(self) -> str:
        return "CSV"

    def parse_title(self, raw: str) -> str:
        # TODO: первая строка — заголовок (имена колонок через запятую)
        pass

    def parse_body(self, raw: str) -> list[str]:
        # TODO: остальные строки — строки данных
        pass

    def extract_metadata(self, raw: str) -> dict:
        # TODO: вернуть {"rows": кол-во строк, "columns": кол-во колонок}
        pass


class JsonParser(DocumentParser):
    @property
    def format_name(self) -> str:
        return "JSON"

    def before_parse(self, content: str) -> None:
        # TODO: валидировать JSON перед парсингом
        pass

    def parse_title(self, raw: str) -> str:
        # TODO: значение ключа "title" или "name" из корня JSON
        pass

    def parse_body(self, raw: str) -> list[str]:
        # TODO: элементы массива "items" или "data", каждый как строка
        pass

    def extract_metadata(self, raw: str) -> dict:
        # TODO: вернуть все ключи верхнего уровня кроме title/items/data
        pass


class HtmlParser(DocumentParser):
    @property
    def format_name(self) -> str:
        return "HTML"

    def parse_title(self, raw: str) -> str:
        # TODO: содержимое тега <title> или <h1>
        pass

    def parse_body(self, raw: str) -> list[str]:
        # TODO: содержимое всех тегов <p>
        pass

    def extract_metadata(self, raw: str) -> dict:
        # TODO: содержимое тегов <meta name="..."> как {"name": "content"}
        pass


# Ожидаемый результат:
# csv_content = "name,age,city\nAlice,30,Moscow\nBob,25,SPb"
# result = CsvParser().parse(csv_content)
# print(result.title)    # "name,age,city"
# print(result.body)     # ["Alice,30,Moscow", "Bob,25,SPb"]
# print(result.metadata) # {"rows": 2, "columns": 3}
#
# json_content = '{"title": "Users", "items": ["Alice", "Bob"], "version": "1.0"}'
# result = JsonParser().parse(json_content)
# print(result.title)    # "Users"
# print(result.body)     # ["Alice", "Bob"]
# print(result.metadata) # {"version": "1.0"}

from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass


@dataclass
class ReportData:
    title: str
    rows: list[dict]
    summary: dict
    extra: dict


class ReportGenerator(ABC):
    def generate(self, filters: dict | None = None) -> ReportData:
        """Шаблонный метод."""
        raw_data = self.collect_data()
        filtered = self.filter_data(raw_data, filters or {})
        aggregated = self.aggregate(filtered)
        self.after_aggregate(aggregated)  # хук
        formatted = self.format_report(aggregated)
        self.save_report(formatted)
        return formatted

    # Хук
    def after_aggregate(self, data: ReportData) -> None:
        pass

    # Шаг с реализацией по умолчанию
    def filter_data(self, data: list[dict],
                    filters: dict) -> list[dict]:
        # TODO: фильтровать по совпадению ключ-значение из filters
        pass

    def save_report(self, report: ReportData) -> None:
        print(f"[Report] Сохранено: '{report.title}' "
              f"({len(report.rows)} строк)")

    # Абстрактные шаги
    @abstractmethod
    def collect_data(self) -> list[dict]: ...

    @abstractmethod
    def aggregate(self, data: list[dict]) -> ReportData: ...

    @abstractmethod
    def format_report(self, data: ReportData) -> ReportData: ...


class SalesReport(ReportGenerator):
    def __init__(self, sales_db: list[dict]) -> None:
        self._db = sales_db

    def collect_data(self) -> list[dict]:
        # TODO: вернуть данные о продажах из _db
        pass

    def aggregate(self, data: list[dict]) -> ReportData:
        # TODO: сгруппировать по region, посчитать total_sales и avg_order
        pass

    def format_report(self, data: ReportData) -> ReportData:
        # TODO: добавить в каждую строку поле "rank" (ранг по продажам)
        pass

    def after_aggregate(self, data: ReportData) -> None:
        # TODO: добавить в summary["top_region"] регион с макс. продажами
        pass


class UserActivityReport(ReportGenerator):
    def __init__(self, events_db: list[dict]) -> None:
        self._db = events_db

    def collect_data(self) -> list[dict]:
        # TODO: вернуть события из _db
        pass

    def aggregate(self, data: list[dict]) -> ReportData:
        # TODO: сгруппировать по user_id: кол-во событий, последняя активность
        pass

    def format_report(self, data: ReportData) -> ReportData:
        # TODO: отсортировать строки по убыванию кол-ва событий
        pass


# Ожидаемый результат:
# sales = [
#     {"region": "North", "amount": 1000, "order_id": 1},
#     {"region": "South", "amount": 1500, "order_id": 2},
#     {"region": "North", "amount": 800,  "order_id": 3},
# ]
# report = SalesReport(sales).generate()
# print(report.title)           # "Sales Report"
# print(report.summary)         # {"total": 3300, "top_region": "South"}
# print(report.rows[0]["rank"]) # 1
#
# report = SalesReport(sales).generate(filters={"region": "North"})
# print(len(report.rows))       # 1 (только North)

from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass


@dataclass
class Image:
    width: int
    height: int
    data: list[list[int]]  # упрощённое представление пикселей (0-255)
    filename: str = ""
    format: str = "PNG"

    def clone(self) -> "Image":
        return Image(
            self.width, self.height,
            [row[:] for row in self.data],
            self.filename, self.format
        )


class ImageProcessor(ABC):
    def process(self, source: str, destination: str) -> Image:
        """Шаблонный метод."""
        image = self.load(source)
        self.validate(image)
        image = self.preprocess(image)
        image = self.apply_filter(image)
        image = self.postprocess(image)
        self.save(image, destination)
        return image

    # Шаг с реализацией по умолчанию
    def load(self, path: str) -> Image:
        print(f"[{self.__class__.__name__}] Загрузка: {path}")
        # Возвращаем тестовое изображение
        return Image(
            width=800, height=600,
            data=[[128] * 800 for _ in range(600)],
            filename=path
        )

    def validate(self, image: Image) -> None:
        if image.width == 0 or image.height == 0:
            raise ValueError("Изображение пустое")
        print(f"[{self.__class__.__name__}] Валидация OK: "
              f"{image.width}x{image.height}")

    def preprocess(self, image: Image) -> Image:
        # Хук — по умолчанию без изменений
        return image

    def postprocess(self, image: Image) -> Image:
        # Хук — по умолчанию без изменений
        return image

    def save(self, image: Image, path: str) -> None:
        print(f"[{self.__class__.__name__}] Сохранено: {path} "
              f"({image.width}x{image.height})")

    # Абстрактный шаг
    @abstractmethod
    def apply_filter(self, image: Image) -> Image: ...


class ThumbnailProcessor(ImageProcessor):
    def __init__(self, max_size: int = 200) -> None:
        self.max_size = max_size

    def apply_filter(self, image: Image) -> Image:
        # TODO: уменьшить изображение до max_size по большей стороне,
        #       сохраняя пропорции
        pass

    def postprocess(self, image: Image) -> Image:
        # TODO: кадрировать до квадрата max_size x max_size (обрезать центр)
        pass


class WatermarkProcessor(ImageProcessor):
    def __init__(self, text: str, opacity: float = 0.3) -> None:
        self.text = text
        self.opacity = opacity

    def preprocess(self, image: Image) -> Image:
        # TODO: убедиться что изображение достаточно большое для водяного знака
        pass

    def apply_filter(self, image: Image) -> Image:
        # TODO: "нанести" водяной знак (в data не меняем, просто логируем)
        print(f"[Watermark] Наносим '{self.text}' с прозрачностью {self.opacity}")
        return image


class GrayscaleProcessor(ImageProcessor):
    def apply_filter(self, image: Image) -> Image:
        # TODO: усреднить каждый пиксель (имитация grayscale)
        pass

    def postprocess(self, image: Image) -> Image:
        # TODO: повысить контраст: растянуть диапазон [min,max] → [0,255]
        pass


# Ожидаемый результат:
# thumb = ThumbnailProcessor(max_size=150)
# result = thumb.process("photo.jpg", "thumb.jpg")
# print(result.width, result.height)   # 150 150 (квадрат)
#
# wm = WatermarkProcessor("© MyBrand")
# result = wm.process("photo.jpg", "watermarked.jpg")
# # [Watermark] Наносим '© MyBrand' с прозрачностью 0.3
#
# gs = GrayscaleProcessor()
# result = gs.process("photo.jpg", "gray.jpg")

from __future__ import annotations
from abc import ABC, abstractmethod
from dataclasses import dataclass, field


@dataclass
class CheckoutContext:
    items: list[dict]
    user_id: str | None
    promo_code: str | None = None
    subtotal: float = 0.0
    discount: float = 0.0
    shipping: float = 0.0
    total: float = 0.0
    order_id: str | None = None
    payment_method: str = "card"


class CheckoutProcess(ABC):
    def checkout(self, ctx: CheckoutContext) -> bool:
        """Шаблонный метод."""
        try:
            self.validate_cart(ctx)
            self.apply_discounts(ctx)
            self.calculate_shipping(ctx)
            ctx.total = ctx.subtotal - ctx.discount + ctx.shipping
            if not self.process_payment(ctx):
                return False
            self.create_order(ctx)
            self.send_notification(ctx)
            self.after_checkout(ctx)  # хук
            return True
        except ValueError as e:
            print(f"[Checkout] Ошибка: {e}")
            return False

    # Хук
    def after_checkout(self, ctx: CheckoutContext) -> None:
        pass

    # Шаги с реализацией по умолчанию
    def validate_cart(self, ctx: CheckoutContext) -> None:
        if not ctx.items:
            raise ValueError("Корзина пуста")
        ctx.subtotal = sum(i["price"] * i["qty"] for i in ctx.items)
        print(f"[Checkout] Корзина валидна, подытог: {ctx.subtotal:.2f}")

    def apply_discounts(self, ctx: CheckoutContext) -> None:
        ctx.discount = 0.0

    def send_notification(self, ctx: CheckoutContext) -> None:
        print(f"[Checkout] Уведомление отправлено для заказа {ctx.order_id}")

    # Абстрактные шаги
    @abstractmethod
    def calculate_shipping(self, ctx: CheckoutContext) -> None: ...

    @abstractmethod
    def process_payment(self, ctx: CheckoutContext) -> bool: ...

    @abstractmethod
    def create_order(self, ctx: CheckoutContext) -> None: ...


class StandardCheckout(CheckoutProcess):
    def apply_discounts(self, ctx: CheckoutContext) -> None:
        # TODO: применить промокод если есть (скидка 10%)
        pass

    def calculate_shipping(self, ctx: CheckoutContext) -> None:
        # TODO: бесплатно при subtotal > 1000, иначе 200
        pass

    def process_payment(self, ctx: CheckoutContext) -> bool:
        # TODO: имитировать оплату картой
        print(f"[Standard] Оплата картой: {ctx.total:.2f}")
        return True

    def create_order(self, ctx: CheckoutContext) -> None:
        # TODO: создать order_id = "ORD-{user_id}-{timestamp}"
        pass

    def after_checkout(self, ctx: CheckoutContext) -> None:
        # TODO: начислить бонусные баллы (1% от total)
        pass


class GuestCheckout(CheckoutProcess):
    def calculate_shipping(self, ctx: CheckoutContext) -> None:
        # TODO: фиксированная доставка 300 для гостей
        pass

    def process_payment(self, ctx: CheckoutContext) -> bool:
        print(f"[Guest] Оплата: {ctx.total:.2f}")
        return True

    def create_order(self, ctx: CheckoutContext) -> None:
        # TODO: order_id = "GUEST-{timestamp}", без сохранения в БД
        pass

    def send_notification(self, ctx: CheckoutContext) -> None:
        # TODO: уведомление только на email (без аккаунта нет push)
        print(f"[Guest] Email-уведомление для заказа {ctx.order_id}")


class SubscriptionCheckout(CheckoutProcess):
    def validate_cart(self, ctx: CheckoutContext) -> None:
        # TODO: для подписки корзина всегда содержит 1 товар
        super().validate_cart(ctx)

    def apply_discounts(self, ctx: CheckoutContext) -> None:
        # TODO: скидка 15% на подписку
        pass

    def calculate_shipping(self, ctx: CheckoutContext) -> None:
        ctx.shipping = 0.0  # доставка бесплатна для подписок
        print("[Subscription] Доставка: бесплатно")

    def process_payment(self, ctx: CheckoutContext) -> bool:
        # TODO: списание по сохранённой карте
        print(f"[Subscription] Повторный платёж: {ctx.total:.2f}")
        return True

    def create_order(self, ctx: CheckoutContext) -> None:
        # TODO: order_id = "SUB-{user_id}-{timestamp}"
        pass


# Ожидаемый результат:
# items = [{"name": "Book", "price": 500, "qty": 2}]
# ctx = CheckoutContext(items=items, user_id="user42", promo_code="SAVE10")
# StandardCheckout().checkout(ctx)
# print(ctx.order_id)    # "ORD-user42-..."
# print(ctx.discount)    # 100.0 (10% от 1000)
# print(ctx.shipping)    # 0.0 (бесплатно > 1000)
# print(ctx.total)       # 900.0