面向对象：从零散函数到可协作对象

函数：给我输入，我完成一次处理
对象：我保存自己的状态，并提供围绕这些状态的行为

class Document:
    def __init__(self, title: str, content: str) -> None:
        self.title = title
        self.content = content

python_doc = Document("Python", "Python 适合文本处理。")
rag_doc = Document("RAG", "RAG 会先检索资料，再生成回答。")

class Counter:
    def __init__(self) -> None:
        self.value = 0

    def increase(self) -> None:
        self.value += 1

class ModelConfig:
    def __init__(self, model_name: str, temperature: float) -> None:
        self.model_name = model_name
        self.temperature = temperature


config_a = ModelConfig("model-a", 0.2)
config_b = ModelConfig("model-b", 0.8)

print(config_a.model_name)
print(config_b.model_name)

class ModelConfig:
    supported_provider = "demo"

    def __init__(self, model_name: str) -> None:
        self.model_name = model_name


print(ModelConfig.supported_provider)

class Conversation:
    def __init__(self) -> None:
        self.messages: list[str] = []

    def add_message(self, message: str) -> None:
        self.messages.append(message)

class ModelConfig:
    def __init__(self, model_name: str, temperature: float) -> None:
        self.model_name = model_name
        self.temperature = temperature

    @classmethod
    def deterministic(cls, model_name: str) -> "ModelConfig":
        return cls(model_name=model_name, temperature=0.0)


config = ModelConfig.deterministic("demo-model")

class ModelConfig:
    @staticmethod
    def temperature_is_valid(value: float) -> bool:
        return 0 <= value <= 2

class ModelConfig:
    def __init__(self, temperature: float) -> None:
        self.temperature = temperature

    @property
    def temperature(self) -> float:
        return self._temperature

    @temperature.setter
    def temperature(self, value: float) -> None:
        if not 0 <= value <= 2:
            raise ValueError("temperature 必须在 0 到 2 之间")
        self._temperature = value

config = ModelConfig(0.2)
config.temperature = 0.8
print(config.temperature)

class ApiClient:
    def __init__(self, api_key: str) -> None:
        self._api_key = api_key
        self.__request_count = 0

    def request(self) -> None:
        self.__request_count += 1

from dataclasses import dataclass


@dataclass(frozen=True)
class Document:
    title: str
    content: str

class Document:
    def __init__(self, title: str, content: str) -> None:
        self.title = title
        self.content = content

    def __str__(self) -> str:
        return self.title

    def __repr__(self) -> str:
        return (
            f"Document(title={self.title!r}, "
            f"content={self.content!r})"
        )


document = Document("Python", "Python 基础语法")
print(document)
print(repr(document))

class Document:
    pass


document = Document()
document.title = "Python"

class ModelConfig:
    __slots__ = ("model_name", "temperature")

    def __init__(self, model_name: str, temperature: float) -> None:
        self.model_name = model_name
        self.temperature = temperature

QuestionAnswerService
├── Retriever
└── ModelClient

class Retriever:
    def search(self, question: str) -> list[str]:
        raise NotImplementedError


class LocalRetriever(Retriever):
    def __init__(self, documents: list[str]) -> None:
        self.documents = documents

    def search(self, question: str) -> list[str]:
        return [text for text in self.documents if question in text]

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


class CachedRetriever(NamedRetriever):
    def __init__(self, name: str, cache_size: int) -> None:
        super().__init__(name)
        self.cache_size = cache_size

class JsonMixin:
    def format(self) -> str:
        return "json"


class TextMixin:
    def format(self) -> str:
        return "text"


class Exporter(JsonMixin, TextMixin):
    pass


print(Exporter().format())
print(Exporter.mro())

class LocalRetriever:
    def search(self, question: str) -> list[str]:
        return [f"本地结果：{question}"]


class VectorRetriever:
    def search(self, question: str) -> list[str]:
        return [f"向量结果：{question}"]


def answer_with(retriever, question: str) -> None:
    results = retriever.search(question)
    print(results)


answer_with(LocalRetriever(), "什么是 RAG？")
answer_with(VectorRetriever(), "什么是 RAG？")

from dataclasses import dataclass


@dataclass(frozen=True)
class Document:
    title: str
    content: str


class KeywordRetriever:
    def __init__(self, documents: list[Document]) -> None:
        self._documents = list(documents)

    def add(self, document: Document) -> None:
        if not document.content.strip():
            raise ValueError("文档内容不能为空")
        self._documents.append(document)

    def search(self, question: str, limit: int = 2) -> list[Document]:
        if limit <= 0:
            raise ValueError("limit 必须大于 0")

        keywords = set(question.lower().split())
        scored_documents = []

        for document in self._documents:
            content = document.content.lower()
            score = sum(keyword in content for keyword in keywords)
            if score > 0:
                scored_documents.append((score, document))

        scored_documents.sort(key=lambda item: item[0], reverse=True)
        return [document for _, document in scored_documents[:limit]]


documents = [
    Document("虚拟环境", "venv 用于隔离 Python 项目依赖。"),
    Document("异常处理", "异常处理让文件读取失败时仍有明确反馈。"),
    Document("RAG", "RAG 先检索相关文档，再让模型生成回答。"),
]

retriever = KeywordRetriever(documents)
results = retriever.search("Python 依赖如何隔离")

for result in results:
    print(f"{result.title}: {result.content}")

from dataclasses import dataclass


@dataclass(frozen=True)
class Document:
    title: str
    content: str


class KeywordRetriever:
    def __init__(self, documents: list[Document]) -> None:
        self._documents = list(documents)
        self._search_count = 0

    @classmethod
    def from_texts(cls, texts: list[str]) -> "KeywordRetriever":
        documents = [
            Document(title=f"文档 {index}", content=text)
            for index, text in enumerate(texts, start=1)
        ]
        return cls(documents)

    @property
    def document_count(self) -> int:
        return len(self._documents)

    @property
    def search_count(self) -> int:
        return self._search_count

    def search(self, keyword: str) -> list[Document]:
        self._search_count += 1
        return [
            document
            for document in self._documents
            if keyword.lower() in document.content.lower()
        ]


retriever = KeywordRetriever.from_texts(
    ["Python 适合处理文本", "RAG 需要检索资料"]
)

print(retriever.document_count)
print(retriever.search("Python"))
print(retriever.search_count)

class TextHelper:
    def clean(self, text: str) -> str:
        return text.strip()

class BadRetriever:
    documents = []