Builder 模式

from dataclasses import dataclass
from typing import Optional


@dataclass
class Computer:
    """产品类：电脑"""
    cpu: str
    ram: str
    storage: str = "256GB SSD"
    gpu: str = "Integrated"
    has_wifi: bool = True
    has_bluetooth: bool = True


class ComputerBuilder:
    """建造者类"""

    def __init__(self, cpu: str, ram: str):
        """必需参数"""
        self.cpu = cpu
        self.ram = ram
        # 可选参数默认值
        self.storage = "256GB SSD"
        self.gpu = "Integrated"
        self.has_wifi = True
        self.has_bluetooth = True

    def set_storage(self, storage: str) -> 'ComputerBuilder':
        """链式调用"""
        self.storage = storage
        return self

    def set_gpu(self, gpu: str) -> 'ComputerBuilder':
        self.gpu = gpu
        return self

    def set_wifi(self, has_wifi: bool) -> 'ComputerBuilder':
        self.has_wifi = has_wifi
        return self

    def set_bluetooth(self, has_bluetooth: bool) -> 'ComputerBuilder':
        self.has_bluetooth = has_bluetooth
        return self

    def build(self) -> Computer:
        """构建最终对象"""
        return Computer(
            cpu=self.cpu,
            ram=self.ram,
            storage=self.storage,
            gpu=self.gpu,
            has_wifi=self.has_wifi,
            has_bluetooth=self.has_bluetooth
        )


# 使用
def main():
    # 最小配置
    basic = ComputerBuilder("Intel i5", "8GB").build()
    print(f"Basic: {basic}")

    # 游戏配置
    gaming = (ComputerBuilder("Intel i9", "32GB")
              .set_storage("1TB NVMe SSD")
              .set_gpu("RTX 4090")
              .set_wifi(True)
              .set_bluetooth(True)
              .build())
    print(f"Gaming: {gaming}")

    # 办公配置
    office = (ComputerBuilder("Intel i7", "16GB")
              .set_storage("512GB SSD")
              .set_wifi(True)
              .set_bluetooth(False)
              .build())
    print(f"Office: {office}")


if __name__ == "__main__":
    main()

from abc import ABC, abstractmethod
from typing import List
from dataclasses import dataclass, field


@dataclass
class Document:
    """产品类：文档"""
    title: str = ""
    content: str = ""
    footer: str = ""
    sections: List[str] = field(default_factory=list)


class DocumentBuilder(ABC):
    """Builder 抽象类"""

    @abstractmethod
    def build_title(self, title: str) -> None:
        pass

    @abstractmethod
    def build_content(self, content: str) -> None:
        pass

    @abstractmethod
    def build_footer(self, footer: str) -> None:
        pass

    @abstractmethod
    def build_section(self, section: str) -> None:
        pass

    @abstractmethod
    def get_document(self) -> Document:
        pass


class HtmlDocumentBuilder(DocumentBuilder):
    """HTML 文档建造者"""

    def __init__(self):
        self.document = Document()

    def build_title(self, title: str) -> None:
        self.document.title = f"<h1>{title}</h1>"

    def build_content(self, content: str) -> None:
        self.document.content = f"<p>{content}</p>"

    def build_footer(self, footer: str) -> None:
        self.document.footer = f"<footer>{footer}</footer>"

    def build_section(self, section: str) -> None:
        self.document.sections.append(f"<section>{section}</section>")

    def get_document(self) -> Document:
        return self.document


class MarkdownDocumentBuilder(DocumentBuilder):
    """Markdown 文档建造者"""

    def __init__(self):
        self.document = Document()

    def build_title(self, title: str) -> None:
        self.document.title = f"# {title}"

    def build_content(self, content: str) -> None:
        self.document.content = content

    def build_footer(self, footer: str) -> None:
        self.document.footer = f"---\n{footer}"

    def build_section(self, section: str) -> None:
        self.document.sections.append(f"## {section}")

    def get_document(self) -> Document:
        return self.document


class DocumentDirector:
    """Director：指挥构建过程"""

    def __init__(self, builder: DocumentBuilder):
        self.builder = builder

    def set_builder(self, builder: DocumentBuilder) -> None:
        self.builder = builder

    def construct_simple_document(self, title: str, content: str) -> Document:
        """构建简单文档"""
        self.builder.build_title(title)
        self.builder.build_content(content)
        self.builder.build_footer("Generated by Builder Pattern")
        return self.builder.get_document()

    def construct_complex_document(self, title: str, content: str, sections: List[str]) -> Document:
        """构建复杂文档"""
        self.builder.build_title(title)
        self.builder.build_content(content)
        for section in sections:
            self.builder.build_section(section)
        self.builder.build_footer("© 2025 Builder Pattern Demo")
        return self.builder.get_document()


# 使用
def main():
    director = DocumentDirector(HtmlDocumentBuilder())

    # 构建 HTML 文档
    html_builder = HtmlDocumentBuilder()
    director.set_builder(html_builder)
    html_doc = director.construct_complex_document(
        "Builder Pattern",
        "This is a design pattern for building complex objects.",
        ["Introduction", "Implementation", "Examples"]
    )
    print(f"HTML Document: {html_doc}")

    # 构建 Markdown 文档
    md_builder = MarkdownDocumentBuilder()
    director.set_builder(md_builder)
    md_doc = director.construct_complex_document(
        "Builder Pattern",
        "This is a design pattern for building complex objects.",
        ["Introduction", "Implementation", "Examples"]
    )
    print(f"Markdown Document: {md_doc}")


if __name__ == "__main__":
    main()

from typing import List, Optional


class SQLQueryBuilder:
    """SQL 查询构建器"""

    def __init__(self):
        self._select: List[str] = []
        self._from: Optional[str] = None
        self._where: List[str] = []
        self._group_by: List[str] = []
        self._order_by: List[str] = []
        self._limit: Optional[int] = None

    def select(self, *columns: str) -> 'SQLQueryBuilder':
        """添加 SELECT 字段"""
        self._select.extend(columns)
        return self

    def from_table(self, table: str) -> 'SQLQueryBuilder':
        """添加 FROM 表"""
        self._from = table
        return self

    def where(self, condition: str) -> 'SQLQueryBuilder':
        """添加 WHERE 条件"""
        self._where.append(condition)
        return self

    def group_by(self, *columns: str) -> 'SQLQueryBuilder':
        """添加 GROUP BY"""
        self._group_by.extend(columns)
        return self

    def order_by(self, *columns: str) -> 'SQLQueryBuilder':
        """添加 ORDER BY"""
        self._order_by.extend(columns)
        return self

    def limit(self, count: int) -> 'SQLQueryBuilder':
        """添加 LIMIT"""
        self._limit = count
        return self

    def build(self) -> str:
        """构建最终的 SQL 查询"""
        query = []

        if not self._select:
            raise ValueError("SELECT cannot be empty")
        query.append(f"SELECT {', '.join(self._select)}")

        if not self._from:
            raise ValueError("FROM table is required")
        query.append(f"FROM {self._from}")

        if self._where:
            query.append(f"WHERE {' AND '.join(self._where)}")

        if self._group_by:
            query.append(f"GROUP BY {', '.join(self._group_by)}")

        if self._order_by:
            query.append(f"ORDER BY {', '.join(self._order_by)}")

        if self._limit:
            query.append(f"LIMIT {self._limit}")

        return " ".join(query)


# 使用
def main():
    # 简单查询
    query1 = (SQLQueryBuilder()
              .select("*")
              .from_table("users")
              .build())
    print(f"Query 1: {query1}")

    # 复杂查询
    query2 = (SQLQueryBuilder()
              .select("name", "email", "COUNT(*) as count")
              .from_table("users")
              .where("age > 18")
              .where("status = 'active'")
              .group_by("name", "email")
              .order_by("count DESC")
              .limit(10)
              .build())
    print(f"Query 2: {query2}")


if __name__ == "__main__":
    main()

from typing import Callable, TypeVar, TypeVarTuple

T = TypeVar('T')


class ConfigBuilder:
    """配置构建器"""

    def __init__(self):
        self.config = {}

    def set(self, key: str, value: str) -> 'ConfigBuilder':
        self.config[key] = value
        return self

    def set_multiple(self, **kwargs) -> 'ConfigBuilder':
        self.config.update(kwargs)
        return self

    def remove(self, key: str) -> 'ConfigBuilder':
        self.config.pop(key, None)
        return self

    def build(self) -> dict:
        return self.config.copy()


# 函数式构建器
def build_config(configurator: Callable[[ConfigBuilder], None]) -> dict:
    """
    函数式构建器
    接收一个函数来配置 Builder
    """
    builder = ConfigBuilder()
    configurator(builder)
    return builder.build()


# 使用
def main():
    # 标准方式
    config1 = (ConfigBuilder()
               .set("host", "localhost")
               .set("port", "8080")
               .set("debug", "true")
               .build())
    print(f"Config 1: {config1}")

    # 函数式方式
    config2 = build_config(
        lambda b: b.set("host", "localhost")
                   .set("port", "5432")
                   .set("database", "mydb")
                   .set_multiple(
                       user="admin",
                       password="secret",
                       timeout="30"
                   )
    )
    print(f"Config 2: {config2}")


if __name__ == "__main__":
    main()