Посетитель

from __future__ import annotations
from abc import ABC, abstractmethod


class ASTVisitor(ABC):
    @abstractmethod
    def visit_number(self, node: "NumberNode"): ...

    @abstractmethod
    def visit_binary_op(self, node: "BinaryOpNode"): ...

    @abstractmethod
    def visit_unary_op(self, node: "UnaryOpNode"): ...

    @abstractmethod
    def visit_variable(self, node: "VariableNode"): ...


class ASTNode(ABC):
    @abstractmethod
    def accept(self, visitor: ASTVisitor): ...


class NumberNode(ASTNode):
    def __init__(self, value: float) -> None:
        self.value = value

    def accept(self, visitor: ASTVisitor):
        return visitor.visit_number(self)


class BinaryOpNode(ASTNode):
    def __init__(self, op: str, left: ASTNode,
                 right: ASTNode) -> None:
        self.op = op  # "+", "-", "*", "/"
        self.left = left
        self.right = right

    def accept(self, visitor: ASTVisitor):
        return visitor.visit_binary_op(self)


class UnaryOpNode(ASTNode):
    def __init__(self, op: str, operand: ASTNode) -> None:
        self.op = op  # "-"
        self.operand = operand

    def accept(self, visitor: ASTVisitor):
        return visitor.visit_unary_op(self)


class VariableNode(ASTNode):
    def __init__(self, name: str) -> None:
        self.name = name

    def accept(self, visitor: ASTVisitor):
        return visitor.visit_variable(self)


class EvalVisitor(ASTVisitor):
    def __init__(self, variables: dict[str, float] | None = None) -> None:
        self.variables = variables or {}

    def visit_number(self, node: NumberNode) -> float:
        return node.value

    def visit_binary_op(self, node: BinaryOpNode) -> float:
        # TODO: вычислить левый и правый операнды, применить op
        pass

    def visit_unary_op(self, node: UnaryOpNode) -> float:
        # TODO: вычислить операнд, применить унарный минус
        pass

    def visit_variable(self, node: VariableNode) -> float:
        # TODO: вернуть значение переменной из self.variables
        pass


class PrintVisitor(ASTVisitor):
    """Инфиксная запись с расстановкой скобок."""

    def visit_number(self, node: NumberNode) -> str:
        return str(node.value)

    def visit_binary_op(self, node: BinaryOpNode) -> str:
        # TODO: вернуть "(left op right)"
        pass

    def visit_unary_op(self, node: UnaryOpNode) -> str:
        # TODO: вернуть "(-operand)"
        pass

    def visit_variable(self, node: VariableNode) -> str:
        return node.name


class RpnVisitor(ASTVisitor):
    """Обратная польская запись: операнды затем оператор."""

    def visit_number(self, node: NumberNode) -> str:
        return str(node.value)

    def visit_binary_op(self, node: BinaryOpNode) -> str:
        # TODO: вернуть "left right op"
        pass

    def visit_unary_op(self, node: UnaryOpNode) -> str:
        # TODO: вернуть "operand NEG"
        pass

    def visit_variable(self, node: VariableNode) -> str:
        return node.name


# Ожидаемый результат:
# # (2 + x) * (y - 3)
# ast = BinaryOpNode("*",
#     BinaryOpNode("+", NumberNode(2), VariableNode("x")),
#     BinaryOpNode("-", VariableNode("y"), NumberNode(3))
# )
# print(ast.accept(PrintVisitor()))          # "((2.0 + x) * (y - 3.0))"
# print(ast.accept(RpnVisitor()))            # "2.0 x + y 3.0 - *"
# print(ast.accept(EvalVisitor({"x": 3, "y": 7})))  # 20.0

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


class CartVisitor(ABC):
    @abstractmethod
    def visit_simple(self, product: "SimpleProduct") -> float: ...

    @abstractmethod
    def visit_bundle(self, product: "BundleProduct") -> float: ...

    @abstractmethod
    def visit_digital(self, product: "DigitalProduct") -> float: ...

    @abstractmethod
    def visit_gift_card(self, card: "GiftCard") -> float: ...


class CartItem(ABC):
    @abstractmethod
    def accept(self, visitor: CartVisitor) -> float: ...

    @property
    @abstractmethod
    def base_price(self) -> float: ...


@dataclass
class SimpleProduct(CartItem):
    name: str
    price: float
    weight_kg: float = 0.5
    tax_rate: float = 0.20  # НДС 20%

    @property
    def base_price(self) -> float:
        return self.price

    def accept(self, visitor: CartVisitor) -> float:
        return visitor.visit_simple(self)


@dataclass
class BundleProduct(CartItem):
    name: str
    items: list[CartItem]
    discount: float = 0.10  # скидка 10% на набор

    @property
    def base_price(self) -> float:
        return sum(i.base_price for i in self.items)

    def accept(self, visitor: CartVisitor) -> float:
        return visitor.visit_bundle(self)


@dataclass
class DigitalProduct(CartItem):
    name: str
    price: float
    tax_rate: float = 0.0  # цифровые товары без НДС

    @property
    def base_price(self) -> float:
        return self.price

    def accept(self, visitor: CartVisitor) -> float:
        return visitor.visit_digital(self)


@dataclass
class GiftCard(CartItem):
    nominal: float
    recipient: str = ""

    @property
    def base_price(self) -> float:
        return self.nominal

    def accept(self, visitor: CartVisitor) -> float:
        return visitor.visit_gift_card(self)


class PriceCalculator(CartVisitor):
    def visit_simple(self, product: SimpleProduct) -> float:
        return product.price

    def visit_bundle(self, product: BundleProduct) -> float:
        # TODO: сумма всех элементов с учётом скидки набора
        pass

    def visit_digital(self, product: DigitalProduct) -> float:
        return product.price

    def visit_gift_card(self, card: GiftCard) -> float:
        return card.nominal

    def total(self, items: list[CartItem]) -> float:
        return sum(item.accept(self) for item in items)


class ShippingCalculator(CartVisitor):
    BASE_RATE = 100.0  # 100 руб/кг

    def visit_simple(self, product: SimpleProduct) -> float:
        # TODO: стоимость по весу (BASE_RATE * weight_kg)
        pass

    def visit_bundle(self, product: BundleProduct) -> float:
        # TODO: сумма доставки всех элементов бандла
        pass

    def visit_digital(self, product: DigitalProduct) -> float:
        return 0.0  # цифровые не требуют доставки

    def visit_gift_card(self, card: GiftCard) -> float:
        return 0.0  # подарочные карты без доставки

    def total(self, items: list[CartItem]) -> float:
        return sum(item.accept(self) for item in items)


class TaxCalculator(CartVisitor):
    def visit_simple(self, product: SimpleProduct) -> float:
        # TODO: price * tax_rate
        pass

    def visit_bundle(self, product: BundleProduct) -> float:
        # TODO: налоги со всех элементов бандла
        pass

    def visit_digital(self, product: DigitalProduct) -> float:
        return product.price * product.tax_rate

    def visit_gift_card(self, card: GiftCard) -> float:
        return 0.0  # подарочные карты без налога

    def total(self, items: list[CartItem]) -> float:
        return sum(item.accept(self) for item in items)


# Ожидаемый результат:
# items = [
#     SimpleProduct("Книга", 500.0, weight_kg=0.3),
#     BundleProduct("Набор", [
#         SimpleProduct("Ручка", 100.0, weight_kg=0.1),
#         SimpleProduct("Тетрадь", 150.0, weight_kg=0.2),
#     ], discount=0.10),
#     DigitalProduct("Курс Python", 2000.0),
#     GiftCard(1000.0, "Alice"),
# ]
# price = PriceCalculator()
# print(f"Стоимость: {price.total(items):.2f}")    # 500+225+2000+1000 = 3725
# ship = ShippingCalculator()
# print(f"Доставка: {ship.total(items):.2f}")      # 30+30+0+0 = 60
# tax = TaxCalculator()
# print(f"Налог: {tax.total(items):.2f}")          # 100+45+0+0 = 145

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


class FSVisitor(ABC):
    @abstractmethod
    def visit_file(self, node: "File") -> None: ...

    @abstractmethod
    def visit_directory(self, node: "Directory") -> None: ...

    @abstractmethod
    def visit_symlink(self, node: "SymLink") -> None: ...


class FSNode(ABC):
    def __init__(self, name: str, permissions: int = 0o644) -> None:
        self.name = name
        self.permissions = permissions  # unix-права, например 0o644

    @abstractmethod
    def accept(self, visitor: FSVisitor) -> None: ...

    @property
    @abstractmethod
    def path(self) -> str: ...


@dataclass
class File(FSNode):
    name: str
    size_bytes: int = 0
    content_hash: str = ""
    permissions: int = field(default=0o644)

    @property
    def path(self) -> str:
        return self.name

    def accept(self, visitor: FSVisitor) -> None:
        visitor.visit_file(self)


@dataclass
class Directory(FSNode):
    name: str
    children: list[FSNode] = field(default_factory=list)
    permissions: int = field(default=0o755)

    @property
    def path(self) -> str:
        return self.name + "/"

    def accept(self, visitor: FSVisitor) -> None:
        visitor.visit_directory(self)

    def add(self, node: FSNode) -> "Directory":
        self.children.append(node)
        return self


@dataclass
class SymLink(FSNode):
    name: str
    target: FSNode | None = None
    permissions: int = field(default=0o777)

    @property
    def path(self) -> str:
        return self.name + " -> " + (self.target.name if self.target else "?")

    def accept(self, visitor: FSVisitor) -> None:
        visitor.visit_symlink(self)


class SizeCalculator(FSVisitor):
    def __init__(self) -> None:
        self.total_bytes = 0

    def visit_file(self, node: File) -> None:
        # TODO: добавить размер файла
        pass

    def visit_directory(self, node: Directory) -> None:
        # TODO: рекурсивно обойти дочерние узлы
        pass

    def visit_symlink(self, node: SymLink) -> None:
        pass  # симлинки не добавляют размер


class SearchVisitor(FSVisitor):
    def __init__(self, pattern: str) -> None:
        self.pattern = pattern
        self.results: list[FSNode] = []

    def visit_file(self, node: File) -> None:
        # TODO: проверить fnmatch(node.name, self.pattern)
        pass

    def visit_directory(self, node: Directory) -> None:
        # TODO: рекурсивно обойти дочерние узлы
        pass

    def visit_symlink(self, node: SymLink) -> None:
        # TODO: проверить имя симлинка
        pass


class PermissionsAuditor(FSVisitor):
    """Находит файлы с потенциально опасными правами (world-writable)."""

    def __init__(self) -> None:
        self.dangerous: list[FSNode] = []

    def _is_dangerous(self, permissions: int) -> bool:
        # TODO: world-writable = (permissions & 0o002) != 0
        pass

    def visit_file(self, node: File) -> None:
        # TODO: добавить в dangerous если права опасные
        pass

    def visit_directory(self, node: Directory) -> None:
        # TODO: проверить директорию и рекурсивно обойти дочерние
        pass

    def visit_symlink(self, node: SymLink) -> None:
        if self._is_dangerous(node.permissions):
            self.dangerous.append(node)


class DuplicateFinder(FSVisitor):
    """Находит файлы с одинаковым content_hash."""

    def __init__(self) -> None:
        self._hashes: dict[str, list[File]] = {}

    def visit_file(self, node: File) -> None:
        # TODO: группировать файлы по content_hash
        pass

    def visit_directory(self, node: Directory) -> None:
        # TODO: рекурсивно обойти дочерние
        pass

    def visit_symlink(self, node: SymLink) -> None:
        pass

    @property
    def duplicates(self) -> dict[str, list[File]]:
        # TODO: вернуть только группы с len > 1
        pass


# Ожидаемый результат:
# root = Directory("root").add(
#     Directory("src").add(
#         File("main.py", 1024, "abc123")
#     ).add(
#         File("utils.py", 512, "def456")
#     )
# ).add(
#     Directory("backup").add(
#         File("main_copy.py", 1024, "abc123")  # дубль
#     )
# ).add(
#     File("readme.txt", 256, "xyz999", permissions=0o666)
# ).add(
#     File("secret.sh", 128, "sec001", permissions=0o777)  # опасный
# )
# calc = SizeCalculator(); root.accept(calc)
# print(calc.total_bytes)   # 2944
# search = SearchVisitor("*.py"); root.accept(search)
# print([f.name for f in search.results])  # ["main.py","utils.py","main_copy.py"]
# dupes = DuplicateFinder(); root.accept(dupes)
# print(dupes.duplicates)   # {"abc123": [main.py, main_copy.py]}

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


class DOMVisitor(ABC):
    @abstractmethod
    def visit_text(self, node: "TextNode") -> None: ...

    @abstractmethod
    def visit_element(self, node: "ElementNode") -> None: ...

    @abstractmethod
    def visit_comment(self, node: "CommentNode") -> None: ...


class DOMNode(ABC):
    @abstractmethod
    def accept(self, visitor: DOMVisitor) -> None: ...


@dataclass
class TextNode(DOMNode):
    content: str

    def accept(self, visitor: DOMVisitor) -> None:
        visitor.visit_text(self)


@dataclass
class CommentNode(DOMNode):
    content: str

    def accept(self, visitor: DOMVisitor) -> None:
        visitor.visit_comment(self)


@dataclass
class ElementNode(DOMNode):
    tag: str
    attributes: dict[str, str] = field(default_factory=dict)
    children: list[DOMNode] = field(default_factory=list)
    self_closing: bool = False  # <br/>, <img/>

    def accept(self, visitor: DOMVisitor) -> None:
        visitor.visit_element(self)

    def add(self, child: DOMNode) -> "ElementNode":
        self.children.append(child)
        return self


class HtmlRenderer(DOMVisitor):
    def __init__(self) -> None:
        self._parts: list[str] = []

    def visit_text(self, node: TextNode) -> None:
        self._parts.append(node.content)

    def visit_comment(self, node: CommentNode) -> None:
        self._parts.append(f"<!-- {node.content} -->")

    def visit_element(self, node: ElementNode) -> None:
        # TODO: собрать открывающий тег с атрибутами,
        #       рекурсивно обойти children, добавить закрывающий тег
        pass

    def render(self) -> str:
        return "".join(self._parts)


class TextExtractor(DOMVisitor):
    def __init__(self) -> None:
        self._texts: list[str] = []

    def visit_text(self, node: TextNode) -> None:
        # TODO: добавить текст (strip пробелов)
        pass

    def visit_comment(self, node: CommentNode) -> None:
        pass  # комментарии игнорируем

    def visit_element(self, node: ElementNode) -> None:
        # TODO: рекурсивно обойти children
        pass

    @property
    def text(self) -> str:
        return " ".join(t for t in self._texts if t)


class LinkCollector(DOMVisitor):
    def __init__(self) -> None:
        self.links: list[dict[str, str]] = []

    def visit_text(self, node: TextNode) -> None:
        pass

    def visit_comment(self, node: CommentNode) -> None:
        pass

    def visit_element(self, node: ElementNode) -> None:
        # TODO: если тег "a" и есть атрибут "href" — добавить в links
        #       {"href": ..., "text": текстовое содержимое ссылки}
        #       рекурсивно обойти children
        pass


class WordCounter(DOMVisitor):
    def __init__(self) -> None:
        self.count = 0

    def visit_text(self, node: TextNode) -> None:
        # TODO: посчитать слова в тексте (split по пробелам)
        pass

    def visit_comment(self, node: CommentNode) -> None:
        pass

    def visit_element(self, node: ElementNode) -> None:
        # TODO: рекурсивно обойти children
        pass


# Ожидаемый результат:
# doc = ElementNode("html").add(
#     ElementNode("head").add(
#         ElementNode("title").add(TextNode("Моя страница"))
#     )
# ).add(
#     ElementNode("body").add(
#         CommentNode("Основной контент")
#     ).add(
#         ElementNode("h1").add(TextNode("Привет, мир!"))
#     ).add(
#         ElementNode("p").add(TextNode("Это ")).add(
#             ElementNode("a", {"href": "https://example.com"}).add(TextNode("ссылка"))
#         ).add(TextNode(" на сайт."))
#     )
# )
# renderer = HtmlRenderer(); doc.accept(renderer)
# print(renderer.render())
# extractor = TextExtractor(); doc.accept(extractor)
# print(extractor.text)   # "Моя страница Привет, мир! Это ссылка на сайт."
# links = LinkCollector(); doc.accept(links)
# print(links.links)      # [{"href": "https://example.com", "text": "ссылка"}]
# wc = WordCounter(); doc.accept(wc)
# print(wc.count)         # 7