# -*- coding: utf-8 -*-
"""Model Recipe 插件接口与样例协议。

对应 issue #34（父 EPIC #5「③ AI 模型框架 配置化重构」、PRD 5.3
「网络结构策略 / 模板化技术路径」）。

PRD 5.3 的核心诉求
------------------

采用「固定主干网络 + 可配置超参」为默认模式；同时提供 **Model Recipe
注册表**，允许高级行业模板通过 *声明式 recipe* 选择不同网络结构（如
LSTM 用于时序、GNN 用于跨工序），**新增结构走插件注册而非改内核**。

验收口径（PRD 5.3 / EPIC #5）：同一框架加载「树脂」与「Ti」两套 Recipe
均能跑通——切换模板仅改 Recipe，模型代码零改动。

本模块交付什么
--------------

1. **``ModelRecipe``**：声明式模型结构注册项。一个 Recipe 描述「用什么网络
   主干 + 如何从超参包构造一个可训练/可推理的模型」。它是一个不可变数据
   对象，``to_dict``/``repr`` 可序列化往返，便于配置台展示与审计。
2. **``RECIPES`` 全局注册表 + ``register_recipe`` / ``get_recipe`` /
   ``build_model`` / ``list_recipes``**：插件式注册 API。新增网络结构
   （如自研 GNN）只需 ``register_recipe``，不动内核——对齐 PRD「新增结构
   走插件注册」理念，并与 issue #35 的 ``register_operator``（特征算子
   插件）形成「特征层 + 结构层」两级插件体系。
3. **内置网络主干工厂**：覆盖 PRD 5.3 四类模型模板的全部默认结构——
   ``gbdt`` / ``dnn`` / ``lstm`` / ``gnn``。每个工厂是纯函数
   ``build(hyperparams) -> ModelHandle``，返回统一的 ``ModelHandle``
   （``fit`` / ``predict`` / ``to_dict``）。
4. **四类内置 Recipe**：与 PRD 5.3「四类模型模板」1:1 映射——质量预测 /
   工艺优化 / 异常检测 / 跨工序寻优，默认绑定到 ``gbdt``/``dnn`` 主干，
   高级模板可改绑 ``lstm``/``gnn``。
5. **样例协议（``samples/`` JSON）**：树脂 Recipe（``resin``）+ Ti Recipe
   （``ti``）两套超参包样例，直接验证「同框架加载两套 Recipe 均跑通」的
   验收口径。

零外部强依赖
------------

* 训练/推理默认走 **纯 Python stub 主干**（``StubBackbone``）：无
  sklearn / xgboost / torch 时也能加载、注册、构造、（伪）拟合与预测，
   保证边缘 / 离线 / CI 环境可加载与校验——与 issue #35 的「numpy 可选」
   策略一致。
* 当运行环境存在 ``sklearn`` 时，``gbdt``/``dnn`` 主干自动升级为真实
  sklearn 实现（梯度提升回归 / MLP），其余情况退化为 stub，不影响接口
   契约与测试。
"""

from __future__ import annotations

import copy
import json
import math
import os
from dataclasses import dataclass, field
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple

__all__ = [
    # 数据对象
    "ModelRecipe",
    "ModelHandle",
    "RecipeError",
    # 注册表 API
    "RECIPES",
    "register_recipe",
    "get_recipe",
    "list_recipes",
    "build_model",
    # 内置主干工厂
    "BACKBONES",
    "register_backbone",
    "gbdt_backbone",
    "dnn_backbone",
    "lstm_backbone",
    "gnn_backbone",
    "stub_backbone",
    # 样例协议
    "load_sample_recipe",
    "SAMPLE_RECIPES",
    # 超参包校验
    "validate_hyperparam_pack",
    "RECIPE_KINDS",
]

# ---------------------------------------------------------------------------
# 可选依赖探测（与 issue #35 feature_spec 的 numpy 可选策略一致）
# ---------------------------------------------------------------------------
try:  # pragma: no cover - 依赖环境相关
    import numpy as _np  # type: ignore
    _HAS_NUMPY = True
except Exception:  # pragma: no cover
    _np = None
    _HAS_NUMPY = False

try:  # pragma: no cover - 依赖环境相关
    from sklearn.ensemble import GradientBoostingRegressor as _GBR  # type: ignore
    from sklearn.neural_network import MLPRegressor as _MLPR  # type: ignore
    _HAS_SKLEARN = True
except Exception:  # pragma: no cover
    _GBR = None
    _MLPR = None
    _HAS_SKLEARN = False


class RecipeError(ValueError):
    """Recipe / 超参包语义错误（未知 recipe / 主干 / 参数缺失等）。"""


# PRD 5.3 四类模型模板的合法 ``kind``（与超参包 ``task`` 字段对齐）。
RECIPE_KINDS: Tuple[str, ...] = (
    "quality_predict",      # ① 质量预测
    "process_optimize",     # ② 工艺优化 / 配方推荐
    "anomaly_detect",       # ③ 异常检测 / 杂质预警
    "cross_process",        # ④ 跨工序关联寻优
)


# ---------------------------------------------------------------------------
# ModelHandle：统一的模型句柄（fit / predict / to_dict）
# ---------------------------------------------------------------------------
class ModelHandle:
    """统一的模型句柄，屏蔽底层主干（sklearn / stub）差异。

    所有主干工厂返回本类实例，使训练/推理流水线（issue #40）与配置台
    （issue #62~#67）只需面向同一接口编程。``fit`` / ``predict`` 对输入
    做最小校验后委托给 ``_impl``。
    """

    __slots__ = ("recipe_id", "backbone", "hyperparams", "_impl", "fitted")

    def __init__(
        self,
        recipe_id: str,
        backbone: str,
        hyperparams: Dict[str, Any],
        impl: Any,
    ) -> None:
        self.recipe_id = recipe_id
        self.backbone = backbone
        self.hyperparams: Dict[str, Any] = dict(hyperparams)
        self._impl = impl
        self.fitted = False

    # -- 训练 / 推理 -------------------------------------------------------
    def fit(self, X: Sequence[Sequence[float]], y: Optional[Sequence[float]] = None) -> "ModelHandle":
        """拟合。无监督主干（anomaly_detect）可忽略 ``y``。"""
        rows = self._coerce_X(X)
        if y is not None:
            yv = [float(v) for v in y]
            if len(yv) != len(rows):
                raise ValueError(f"X/y 长度不一致：{len(rows)} vs {len(yv)}")
        else:
            yv = None
        self._impl_fit(rows, yv)
        self.fitted = True
        return self

    def predict(self, X: Sequence[Sequence[float]]) -> List[float]:
        """推理。未拟合则 fail-fast（fail-closed，避免静默返回垃圾值）。"""
        if not self.fitted:
            raise RecipeError("模型尚未 fit，禁止 predict（fail-closed）")
        rows = self._coerce_X(X)
        return self._impl_predict(rows)

    # -- 序列化 ------------------------------------------------------------
    def to_dict(self) -> Dict[str, Any]:
        return {
            "recipe_id": self.recipe_id,
            "backbone": self.backbone,
            "hyperparams": copy.deepcopy(self.hyperparams),
            "fitted": self.fitted,
        }

    def __repr__(self) -> str:  # pragma: no cover - 调试用
        return (
            f"ModelHandle(recipe_id={self.recipe_id!r}, backbone={self.backbone!r}, "
            f"hyperparams={self.hyperparams!r}, fitted={self.fitted})"
        )

    # -- 内部 --------------------------------------------------------------
    @staticmethod
    def _coerce_X(X: Sequence[Sequence[float]]) -> List[List[float]]:
        if X is None:
            raise ValueError("X 不能为 None")
        rows: List[List[float]] = []
        width: Optional[int] = None
        for r in X:
            row = [float(v) for v in r]
            if width is None:
                width = len(row)
            elif len(row) != width:
                raise ValueError(f"特征宽度不一致：{width} vs {len(row)}")
            rows.append(row)
        if not rows:
            raise ValueError("X 不能为空")
        return rows

    def _impl_fit(self, rows: List[List[float]], y: Optional[List[float]]) -> None:
        method = getattr(self._impl, "iaop_fit", None)
        if method is None:
            return  # stub 主干无需训练
        method(rows, y)

    def _impl_predict(self, rows: List[List[float]]) -> List[float]:
        method = getattr(self._impl, "iaop_predict", None)
        if method is None:
            # 兜底：返回零向量（理论上不会走到，注册时已校验）
            return [0.0 for _ in rows]
        return [float(v) for v in method(rows)]


# ---------------------------------------------------------------------------
# 内置主干工厂：gbdt / dnn / lstm / gnn（无第三方依赖时退化为 stub）
# ---------------------------------------------------------------------------
def _as_matrix(rows: Sequence[Sequence[float]]):
    """把嵌套列表归一为 numpy 数组（有 numpy）或原生 list。"""
    if _HAS_NUMPY:
        return _np.asarray(rows, dtype=float)
    return [list(r) for r in rows]


def _as_vector(y: Sequence[float]):
    if _HAS_NUMPY:
        return _np.asarray(y, dtype=float)
    return [float(v) for v in y]


def stub_backbone(hyperparams: Dict[str, Any]) -> Any:
    """纯 Python stub 主干：均值/常数预测，无任何第三方依赖。

    作为 ``gbdt``/``dnn``/``lstm``/``gnn`` 在无 sklearn/torch 环境下的
    退化实现，保证 Recipe 可加载、可（伪）拟合、可推理、可切换——满足
    PRD「新增结构走插件注册」的接口契约，不保证预测精度。
    """
    class _Stub:
        def __init__(self) -> None:
            self._target_mean = 0.0
            self._rows = 0

        def iaop_fit(self, rows, y):
            self._rows = len(rows)
            if y is not None and len(y) > 0:
                self._target_mean = float(sum(y) / len(y))

        def iaop_predict(self, rows):
            return [self._target_mean for _ in rows]

    return _Stub()


def gbdt_backbone(hyperparams: Dict[str, Any]) -> Any:
    """梯度提升回归主干（PRD 5.3 质量预测默认 ``algorithm=xgboost``）。

    有 ``sklearn`` 时用 ``GradientBoostingRegressor``；否则退化为
    ``stub_backbone``。超参映射：max_depth / n_estimators / learning_rate。
    """
    if not _HAS_SKLEARN:
        return stub_backbone(hyperparams)
    max_depth = int(hyperparams.get("max_depth", 6))
    n_estimators = int(hyperparams.get("n_estimators", hyperparams.get("n_est", 100)))
    learning_rate = float(hyperparams.get("eta", hyperparams.get("learning_rate", 0.1)))
    return _GBR(
        max_depth=max_depth,
        n_estimators=n_estimators,
        learning_rate=learning_rate,
    )


def dnn_backbone(hyperparams: Dict[str, Any]) -> Any:
    """轻量 DNN 主干（PRD 5.3「轻量 DNN」结构不变 + 可配置超参）。

    有 ``sklearn`` 时用 ``MLPRegressor``；否则退化为 stub。超参映射：
    hidden_layer_sizes / max_iter。
    """
    if not _HAS_SKLEARN:
        return stub_backbone(hyperparams)
    hidden = hyperparams.get("hidden", hyperparams.get("hidden_layer_sizes", (64, 32)))
    if isinstance(hidden, int):
        hidden = (hidden,)
    elif isinstance(hidden, list):
        hidden = tuple(int(x) for x in hidden)
    max_iter = int(hyperparams.get("max_iter", hyperparams.get("epochs", 200)))
    return _MLPR(hidden_layer_sizes=hidden, max_iter=max_iter)


def lstm_backbone(hyperparams: Dict[str, Any]) -> Any:
    """LSTM 时序主干（PRD 5.3「LSTM 用于时序」高级行业模板可选结构）。

    iAOP-Core 内核不强制依赖 torch/tf；本工厂在无 heavy 依赖时退化为
    stub，仅完成「结构可声明、可注册、可切换」的接口契约。真实训练由
    下游模板的插件 Recipe 注入 torch 实现后覆盖（``register_backbone``）。
    """
    # 读取序列长度配置仅用于校验，stub 本身不消费
    _ = int(hyperparams.get("seq_len", hyperparams.get("window", 10)))
    return stub_backbone(hyperparams)


def gnn_backbone(hyperparams: Dict[str, Any]) -> Any:
    """GNN 跨工序主干（PRD 5.3「GNN 用于跨工序」高级行业模板可选结构）。

    同 ``lstm_backbone``：内核不绑定图神经网络框架，退化为 stub；高级
    模板通过插件 Recipe 注入真实实现。
    """
    _ = hyperparams.get("num_nodes", hyperparams.get("edges"))
    return stub_backbone(hyperparams)


# 主干注册表：name -> factory(hyperparams) -> impl
BACKBONES: Dict[str, Callable[[Dict[str, Any]], Any]] = {
    "gbdt": gbdt_backbone,
    "dnn": dnn_backbone,
    "lstm": lstm_backbone,
    "gnn": gnn_backbone,
    "stub": stub_backbone,
}


def register_backbone(
    name: str,
    factory: Callable[[Dict[str, Any]], Any],
) -> None:
    """注册一个网络主干工厂。重复注册同名主干覆盖旧定义（便于测试替换）。"""
    if not name or not name.replace("_", "").replace("-", "").isalnum():
        raise RecipeError(f"非法主干名：{name!r}")
    if not callable(factory):
        raise RecipeError("factory 必须是可调用对象")
    BACKBONES[name] = factory


def _resolve_backbone(name: str) -> Callable[[Dict[str, Any]], Any]:
    if name not in BACKBONES:
        raise RecipeError(
            f"未知网络主干：{name!r}（已注册：{sorted(BACKBONES.keys())}）"
        )
    return BACKBONES[name]


# ---------------------------------------------------------------------------
# ModelRecipe：声明式模型结构注册项（不可变数据对象）
# ---------------------------------------------------------------------------
@dataclass(frozen=True)
class ModelRecipe:
    """一个声明式模型结构 Recipe。

    Attributes
    ----------
    id : str
        Recipe 唯一标识（如 ``quality_predict.default``）。
    kind : str
        任务类型，取值 ``RECIPE_KINDS`` 之一（对齐 PRD 5.3 四类模型模板）。
    backbone : str
        网络主干名，必须在 ``BACKBONES`` 已注册（gbdt/dnn/lstm/gnn/...）。
    default_hyperparams : dict
        默认超参（可被超参包覆盖）。
    required_features : tuple[str, ...]
        该 Recipe 要求的最少特征名（用于超参包校验）。
    description : str
        人类可读说明。
    """

    id: str
    kind: str
    backbone: str
    default_hyperparams: Dict[str, Any] = field(default_factory=dict)
    required_features: Tuple[str, ...] = field(default_factory=tuple)
    description: str = ""

    def __post_init__(self) -> None:
        if not self.id:
            raise RecipeError("Recipe id 不能为空")
        if self.kind not in RECIPE_KINDS:
            raise RecipeError(
                f"非法 kind：{self.kind!r}（合法：{RECIPE_KINDS}）"
            )
        if self.backbone not in BACKBONES:
            raise RecipeError(
                f"未注册的主干：{self.backbone!r}（已注册：{sorted(BACKBONES.keys())}）"
            )
        if not isinstance(self.default_hyperparams, dict):
            raise RecipeError("default_hyperparams 必须是 dict")
        if not isinstance(self.required_features, tuple):
            raise RecipeError("required_features 必须是 tuple")

    def to_dict(self) -> Dict[str, Any]:
        return {
            "id": self.id,
            "kind": self.kind,
            "backbone": self.backbone,
            "default_hyperparams": copy.deepcopy(self.default_hyperparams),
            "required_features": list(self.required_features),
            "description": self.description,
        }

    @classmethod
    def from_dict(cls, d: Dict[str, Any]) -> "ModelRecipe":
        try:
            return cls(
                id=str(d["id"]),
                kind=str(d["kind"]),
                backbone=str(d["backbone"]),
                default_hyperparams=dict(d.get("default_hyperparams", {})),
                required_features=tuple(d.get("required_features", ())),
                description=str(d.get("description", "")),
            )
        except KeyError as e:  # pragma: no cover - 防御性
            raise RecipeError(f"Recipe 缺少字段：{e}") from e

    def merged_hyperparams(self, override: Optional[Dict[str, Any]]) -> Dict[str, Any]:
        """合并默认超参与超参包覆盖（覆盖优先）。"""
        merged = copy.deepcopy(self.default_hyperparams)
        if override:
            merged.update(override)
        return merged


# ---------------------------------------------------------------------------
# Recipe 注册表 + 公开 API
# ---------------------------------------------------------------------------
RECIPES: Dict[str, ModelRecipe] = {}


def register_recipe(recipe: ModelRecipe) -> ModelRecipe:
    """注册一个 Model Recipe 到全局注册表。

    重复注册同 id 覆盖旧定义（便于测试期间替换）。对齐 PRD「新增结构走
    插件注册而非改内核」：高级行业模板（如自研 GNN）只需 ``register_recipe``
    即可接入，无需修改本文件。
    """
    if not isinstance(recipe, ModelRecipe):
        raise RecipeError("register_recipe 入参必须是 ModelRecipe 实例")
    # 再次校验主干（防止 BACKBONES 在 recipe 构造后被反注册）
    _resolve_backbone(recipe.backbone)
    RECIPES[recipe.id] = recipe
    return recipe


def get_recipe(recipe_id: str) -> ModelRecipe:
    """按 id 取 Recipe；不存在则 ``RecipeError``。"""
    if recipe_id not in RECIPES:
        raise RecipeError(
            f"未知 Recipe：{recipe_id!r}（已注册：{sorted(RECIPES.keys())}）"
        )
    return RECIPES[recipe_id]


def list_recipes() -> List[Dict[str, Any]]:
    """列出全部已注册 Recipe（``to_dict`` 形式，按 id 排序）。"""
    return [RECIPES[k].to_dict() for k in sorted(RECIPES.keys())]


def build_model(
    recipe_id: str,
    hyperparams: Optional[Dict[str, Any]] = None,
) -> ModelHandle:
    """按 Recipe + 超参包构造一个可训练/可推理的模型句柄。

    流程：取 Recipe → 合并超参 → 取主干工厂 → 构造 impl → 包成
    ``ModelHandle``。切换模板/行业只需换 ``recipe_id`` 或超参，代码零改动
    ——对齐 PRD 5.3 验收口径。
    """
    recipe = get_recipe(recipe_id)
    merged = recipe.merged_hyperparams(hyperparams)
    factory = _resolve_backbone(recipe.backbone)
    impl = factory(merged)
    return ModelHandle(
        recipe_id=recipe.id,
        backbone=recipe.backbone,
        hyperparams=merged,
        impl=impl,
    )


# ---------------------------------------------------------------------------
# 超参包校验（与 issue #39 hyperparam 互补；本模块只校验 Recipe 相关字段）
# ---------------------------------------------------------------------------
# Recipe 视角下，超参包必须出现的字段（PRD 5.3 超参包 JSON 示例）。
_REQUIRED_PACK_FIELDS: Tuple[str, ...] = ("model_id", "recipe_id", "features")


def validate_hyperparam_pack(pack: Dict[str, Any]) -> List[str]:
    """校验一个超参包在 Recipe 视角下的合法性，返回问题列表（空=通过）。

    与 issue #39 ``hyperparam.py`` 的「spec 非空存在性校验」互补：#39 校验
    特征 ``spec`` 字段本身，本函数校验「recipe_id 是否注册、主干能否构造、
    必需特征是否齐备」等结构层语义。
    """
    issues: List[str] = []
    if not isinstance(pack, dict):
        return ["超参包必须是 dict"]
    for f in _REQUIRED_PACK_FIELDS:
        if f not in pack:
            issues.append(f"缺少必填字段：{f}")

    rid = pack.get("recipe_id")
    if rid is not None:
        if rid not in RECIPES:
            issues.append(
                f"recipe_id {rid!r} 未注册（已注册：{sorted(RECIPES.keys())}）"
            )
        else:
            recipe = RECIPES[rid]
            # 必需特征校验
            if recipe.required_features:
                feats = {f.get("name") for f in pack.get("features", []) if isinstance(f, dict)}
                for req in recipe.required_features:
                    if req not in feats:
                        issues.append(f"Recipe {rid!r} 要求特征 {req!r} 但超参包未提供")
            # 主干可构造性（合并超参后能否实例化，吞掉异常转 issue）
            try:
                merged = recipe.merged_hyperparams(pack.get("hyperparams"))
                _resolve_backbone(recipe.backbone)(merged)
            except Exception as e:  # pragma: no cover - 防御性
                issues.append(f"主干 {recipe.backbone!r} 构造失败：{e}")
    return issues


# ---------------------------------------------------------------------------
# 内置四类 Recipe（PRD 5.3 四类模型模板 1:1 映射，默认主干）
# ---------------------------------------------------------------------------
def _register_builtin_recipes() -> None:
    """注册 PRD 5.3 四类模型模板的默认 Recipe。

    默认主干选「固定主干网络」：质量预测/工艺优化用 gbdt，异常检测用 dnn，
    跨工序寻优用 gnn（高级行业模板可改绑 lstm/gnn）。
    """
    register_recipe(ModelRecipe(
        id="quality_predict.default",
        kind="quality_predict",
        backbone="gbdt",
        default_hyperparams={
            "max_depth": 6,
            "eta": 0.1,
            "n_estimators": 300,
            "objective": "reg:squarederror",
        },
        required_features=("target",),
        description="① 质量预测默认 Recipe：GBDT 主干，输入工艺参数+原料特征，"
                    "输出关键质量指标预测（PRD 5.3）。",
    ))
    register_recipe(ModelRecipe(
        id="process_optimize.default",
        kind="process_optimize",
        backbone="gbdt",
        default_hyperparams={
            "max_depth": 5,
            "n_estimators": 200,
        },
        description="② 工艺优化/配方推荐默认 Recipe：GBDT 主干，输入质量目标+"
                    "约束，输出参数/配方建议（PRD 5.3）。",
    ))
    register_recipe(ModelRecipe(
        id="anomaly_detect.default",
        kind="anomaly_detect",
        backbone="dnn",
        default_hyperparams={
            "hidden": (32, 16),
            "alarm_threshold": {"type": "zscore", "k": 3.0},
        },
        description="③ 异常检测/杂质预警默认 Recipe：轻量 DNN 主干（无监督+"
                    "阈值），输入实时测点，输出异常评分+预警（PRD 5.3）。",
    ))
    register_recipe(ModelRecipe(
        id="cross_process.default",
        kind="cross_process",
        backbone="gnn",
        default_hyperparams={
            "num_nodes": 2,
        },
        description="④ 跨工序关联寻优默认 Recipe：GNN 主干，输入上游(TiCl₄)"
                    "指标，输出下游(海绵钛)寻优建议（PRD 5.3）。",
    ))


_register_builtin_recipes()


# ---------------------------------------------------------------------------
# 样例协议：树脂 / Ti 两套超参包（验证「同框架加载两套 Recipe 均跑通」）
# ---------------------------------------------------------------------------
# 内置样例超参包（PRD 5.3 超参包 JSON 结构 + recipe_id 关联）。验证 EPIC #5
# 验收口径：同一框架加载树脂与 Ti 两套 Recipe 均能 build/fit/predict。
SAMPLE_RECIPES: Dict[str, Dict[str, Any]] = {
    "resin": {
        "model_id": "quality_predict_resin",
        "template": "iAOP-Template-Resin",
        "recipe_id": "quality_predict.default",
        "algorithm": "gbdt",
        "features": [
            {"name": "EMA_resin_temp", "spec": "EMA(树脂温度, 5m)"},
            {"name": "target", "spec": "树脂转化率"},
        ],
        "target": "树脂转化率",
        "objective": "reg:squarederror",
        "hyperparams": {"max_depth": 4, "n_estimators": 120, "eta": 0.1},
        "train_window": "180d",
    },
    "ti": {
        "model_id": "quality_predict_ti",
        "template": "iAOP-Template-Ti",
        "recipe_id": "quality_predict.default",
        "algorithm": "gbdt",
        "features": [
            {"name": "EMA_CLF_TEMP_5m", "spec": "EMA(CLF-01.TEMP, 5m)"},
            {"name": "RollingStd_CL2_10", "spec": "RollingStd(CLF-01.CL2, 10)"},
            {"name": "target", "spec": "Ti_purity"},
        ],
        "target": "Ti_purity",
        "objective": "reg:squarederror",
        "hyperparams": {"max_depth": 6, "n_estimators": 300, "eta": 0.1},
        "train_window": "180d",
        "alarm_threshold": {"type": "zscore", "k": 3.0},
        "drift_check": {"method": "psi", "limit": 0.2},
    },
}


def load_sample_recipe(name: str) -> Dict[str, Any]:
    """按名取内置样例超参包（``resin`` / ``ti``），返回深拷贝。"""
    if name not in SAMPLE_RECIPES:
        raise RecipeError(
            f"未知样例 Recipe：{name!r}（已有：{sorted(SAMPLE_RECIPES.keys())}）"
        )
    return copy.deepcopy(SAMPLE_RECIPES[name])