837 lines
36 KiB
Python
837 lines
36 KiB
Python
import math
|
||
import statistics
|
||
from collections import defaultdict
|
||
from datetime import datetime
|
||
from typing import Any
|
||
|
||
from fastapi import UploadFile
|
||
from sqlalchemy import func, select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from scripts.breeding_stats import fdist
|
||
|
||
from app.api.v1.module_bre.germplasm.model import BreedingGermplasmModel
|
||
from app.api.v1.module_bre.trait.model import TraitModel
|
||
from app.api.v1.module_bre.trial_study.model import TrialStudyModel
|
||
from app.core.base_crud import assert_no_children, assert_parents_exist
|
||
from app.core.base_schema import AuthSchema, ImportResultSchema, PageResultSchema
|
||
from app.core.exceptions import CustomException
|
||
from app.core.logger import logger
|
||
from app.utils.common_util import search_to_dict
|
||
from app.utils.excel_util import ExcelUtil
|
||
|
||
from .crud import (
|
||
DusDescriptorCRUD,
|
||
DusObservationCRUD,
|
||
DusTestCRUD,
|
||
)
|
||
from .model import DusDescriptorModel, DusObservationModel, DusTestModel
|
||
from .schema import (
|
||
DusDescriptorCreateSchema,
|
||
DusDescriptorOutSchema,
|
||
DusDescriptorQueryParam,
|
||
DusDescriptorUpdateSchema,
|
||
DusObservationCreateSchema,
|
||
DusObservationOutSchema,
|
||
DusObservationQueryParam,
|
||
DusObservationUpdateSchema,
|
||
DusTestCreateSchema,
|
||
DusTestOutSchema,
|
||
DusTestQueryParam,
|
||
DusTestUpdateSchema,
|
||
)
|
||
|
||
|
||
def _is_blank(v: Any) -> bool:
|
||
return v is None or (isinstance(v, str) and v.strip() == "")
|
||
|
||
|
||
def _none_if_blank(v: Any) -> Any:
|
||
if _is_blank(v):
|
||
return None
|
||
return str(v).strip() if isinstance(v, str) else v
|
||
|
||
|
||
def _to_int(v: Any) -> int | None:
|
||
if _is_blank(v):
|
||
return None
|
||
try:
|
||
return int(float(str(v).strip()))
|
||
except (TypeError, ValueError):
|
||
return None
|
||
|
||
|
||
def _to_float(v: Any) -> float | None:
|
||
if _is_blank(v):
|
||
return None
|
||
try:
|
||
return float(str(v).strip())
|
||
except (TypeError, ValueError):
|
||
return None
|
||
|
||
|
||
def _variety_obs(rows: list[dict[str, Any]]) -> dict[int, dict[str, list[Any]]]:
|
||
"""把某品种的一组观测行聚成 {descriptor_id: {"numeric": [...], "text": [...]}}。"""
|
||
out: dict[int, dict[str, list[Any]]] = defaultdict(lambda: {"numeric": [], "text": []})
|
||
for r in rows:
|
||
did = r.get("dus_descriptor_id")
|
||
if did is None:
|
||
continue
|
||
if r.get("value_numeric") is not None:
|
||
out[did]["numeric"].append(float(r["value_numeric"]))
|
||
if r.get("value_text") not in (None, ""):
|
||
out[did]["text"].append(str(r["value_text"]))
|
||
return dict(out)
|
||
|
||
|
||
def _merge_obs(target: dict[int, dict[str, list[Any]]], rows: list[dict[str, Any]]) -> None:
|
||
for r in rows:
|
||
did = r.get("dus_descriptor_id")
|
||
if did is None:
|
||
continue
|
||
bucket = target.setdefault(did, {"numeric": [], "text": []})
|
||
if r.get("value_numeric") is not None:
|
||
bucket["numeric"].append(float(r["value_numeric"]))
|
||
if r.get("value_text") not in (None, ""):
|
||
bucket["text"].append(str(r["value_text"]))
|
||
|
||
|
||
def _text_modes(vals: list[str]) -> list[str]:
|
||
if not vals:
|
||
return []
|
||
counts: dict[str, int] = defaultdict(int)
|
||
for s in vals:
|
||
counts[s] += 1
|
||
top = max(counts.values())
|
||
return sorted([s for s, c in counts.items() if c == top])
|
||
|
||
|
||
def distinctness(
|
||
candidate: dict[int, dict[str, list[Any]]],
|
||
references: list[dict[int, dict[str, list[Any]]]],
|
||
descriptor_meta: dict[int, dict[str, Any]],
|
||
alpha: float = 0.01,
|
||
) -> dict[str, Any]:
|
||
"""DUS 特异性统计判定（纯函数，§8.18）。
|
||
|
||
- QN（value_numeric）：候选 vs 每参照单因素 ANOVA → MSE,df →
|
||
LSD = t_crit(α/2,df)·√(MSE·(1/n_cand + 1/n_ref))，|均值差|>LSD 视为 distinct；
|
||
误差自由度<1（无重复）→ 数据不足 pending。
|
||
- PQ/QL（value_text）：表达状态众数比较，候选众数状态 ∉ 参照众数状态集 → distinct。
|
||
|
||
返回逐描述符判定表 + 总体建议（仅 required 描述符驱动）。
|
||
"""
|
||
desc_ids = sorted(set(candidate) | {did for ref in references for did in ref})
|
||
descriptors: list[dict[str, Any]] = []
|
||
distinct_nos: list[str] = []
|
||
required_distinct: list[str] = []
|
||
pending_nos: list[str] = []
|
||
for did in desc_ids:
|
||
meta = descriptor_meta.get(did, {})
|
||
exp_type = str(meta.get("expression_type") or "QN").upper()
|
||
desc_no = str(meta.get("descriptor_no") or did)
|
||
desc_name = meta.get("descriptor_name") or ""
|
||
required = str(meta.get("required") or "0").strip() == "1"
|
||
c_obs = candidate.get(did, {"numeric": [], "text": []})
|
||
refs_obs = [ref.get(did, {"numeric": [], "text": []}) for ref in references]
|
||
row: dict[str, Any] = {
|
||
"descriptor_id": did,
|
||
"descriptor_no": desc_no,
|
||
"descriptor_name": desc_name,
|
||
"expression_type": exp_type,
|
||
"required": "1" if required else "0",
|
||
"candidate_value": None,
|
||
"ref_values": [None] * len(refs_obs),
|
||
"statistic": None,
|
||
"critical": None,
|
||
"df": None,
|
||
"distinct": None,
|
||
"note": None,
|
||
}
|
||
if exp_type == "QN":
|
||
cand_vals = [v for v in c_obs.get("numeric", []) if v is not None]
|
||
ref_val_lists = [
|
||
[v for v in r.get("numeric", []) if v is not None] for r in refs_obs
|
||
]
|
||
row["candidate_value"] = round(statistics.fmean(cand_vals), 4) if cand_vals else None
|
||
row["ref_values"] = [
|
||
round(statistics.fmean(vs), 4) if vs else None for vs in ref_val_lists
|
||
]
|
||
groups = [(0, cand_vals)] + [
|
||
(i + 1, vs) for i, vs in enumerate(ref_val_lists) if vs
|
||
]
|
||
groups = [g for g in groups if g[1]]
|
||
k = len(groups)
|
||
n_total = sum(len(vs) for _, vs in groups)
|
||
df_error = n_total - k
|
||
if k < 2 or df_error < 1:
|
||
row["distinct"] = None
|
||
row["note"] = "数据不足：QN 需候选与参照均有有效值且具备重复（误差自由度≥1），无法做 LSD"
|
||
pending_nos.append(desc_no)
|
||
descriptors.append(row)
|
||
continue
|
||
means: dict[int, float] = {}
|
||
sse = 0.0
|
||
for gi, vals in groups:
|
||
m = statistics.fmean(vals)
|
||
means[gi] = m
|
||
sse += sum((x - m) ** 2 for x in vals)
|
||
mse = sse / df_error
|
||
t = fdist.t_crit(alpha, df_error)
|
||
row["df"] = df_error
|
||
row["critical"] = round(t, 4)
|
||
lsd_used = None
|
||
row["distinct"] = False
|
||
row["note"] = "与所有参照均未达显著差异"
|
||
for i, (gi, vals) in enumerate(groups):
|
||
if gi == 0:
|
||
continue
|
||
n_c, n_r = len(cand_vals), len(vals)
|
||
lsd = t * math.sqrt(mse * (1.0 / n_c + 1.0 / n_r))
|
||
lsd_used = lsd
|
||
if abs(means[0] - means[gi]) > lsd:
|
||
row["distinct"] = True
|
||
row["note"] = (
|
||
f"与参照{i}显著不同（|Δ|={abs(means[0] - means[gi]):.3f} > LSD={lsd:.3f}）"
|
||
)
|
||
break
|
||
row["statistic"] = round(lsd_used, 4) if lsd_used is not None else None
|
||
else:
|
||
cand_modes = _text_modes(c_obs.get("text", []))
|
||
ref_modes_all = [_text_modes(r.get("text", [])) for r in refs_obs]
|
||
row["candidate_value"] = " / ".join(cand_modes) if cand_modes else None
|
||
row["ref_values"] = [" / ".join(ms) if ms else None for ms in ref_modes_all]
|
||
if not cand_modes:
|
||
row["distinct"] = None
|
||
row["note"] = "数据不足：PQ/QL 需候选表达状态"
|
||
pending_nos.append(desc_no)
|
||
else:
|
||
union = {s for ms in ref_modes_all for s in ms}
|
||
overlap = any(s in union for s in cand_modes)
|
||
row["distinct"] = not overlap
|
||
row["note"] = (
|
||
f"候选状态{'/'.join(cand_modes)} 不在参照状态集"
|
||
if row["distinct"]
|
||
else f"候选状态{'/'.join(cand_modes)} 与参照重叠"
|
||
)
|
||
if row["distinct"] is True:
|
||
distinct_nos.append(desc_no)
|
||
if required:
|
||
required_distinct.append(desc_no)
|
||
descriptors.append(row)
|
||
|
||
req_pending = [d["descriptor_no"] for d in descriptors if d["required"] == "1" and d["distinct"] is None]
|
||
req_distinct = [d["descriptor_no"] for d in descriptors if d["required"] == "1" and d["distinct"] is True]
|
||
if req_pending:
|
||
suggestion = "pending"
|
||
elif req_distinct:
|
||
suggestion = "distinct"
|
||
else:
|
||
suggestion = "not_distinct"
|
||
warning = None
|
||
if pending_nos:
|
||
shown = "、".join(pending_nos[:8])
|
||
if len(pending_nos) > 8:
|
||
shown += "…"
|
||
warning = f"{len(pending_nos)} 个描述符数据不足未判定：{shown}"
|
||
return {
|
||
"alpha": alpha,
|
||
"n_references": len(references),
|
||
"descriptors": descriptors,
|
||
"distinct_descriptors": distinct_nos,
|
||
"n_distinct": len(distinct_nos),
|
||
"required_distinct": required_distinct,
|
||
"n_required_distinct": len(required_distinct),
|
||
"suggestion": suggestion,
|
||
"warning": warning,
|
||
}
|
||
|
||
|
||
class DusService:
|
||
"""DUS/品种保护 模块服务层（描述符模板 / 测试记录 / 观测 三组资源）。"""
|
||
|
||
def __init__(self, auth: AuthSchema, db: AsyncSession) -> None:
|
||
self.auth = auth
|
||
self.db = db
|
||
|
||
# ---------- 描述符模板 ----------
|
||
async def _check_descriptor_no(self, no: str, exclude_id: int | None = None) -> None:
|
||
if _is_blank(no):
|
||
raise CustomException(msg="描述符编号不能为空")
|
||
result = await self.db.execute(
|
||
select(DusDescriptorModel.id).where(
|
||
DusDescriptorModel.descriptor_no == str(no).strip(),
|
||
DusDescriptorModel.is_deleted.is_(False),
|
||
)
|
||
)
|
||
obj_id = result.scalar_one_or_none()
|
||
if obj_id is not None and obj_id != exclude_id:
|
||
raise CustomException(msg=f"描述符编号 {no} 已存在", status_code=409)
|
||
|
||
async def _attach_trait_labels(self, items: list[DusDescriptorOutSchema]) -> None:
|
||
ids = {getattr(it, "trait_id") for it in items if getattr(it, "trait_id")}
|
||
if not ids:
|
||
return
|
||
rows = (await self.db.execute(
|
||
select(TraitModel.id, TraitModel.trait_name).where(TraitModel.id.in_(ids))
|
||
)).all()
|
||
ref_map = {rid: name for rid, name in rows}
|
||
for it in items:
|
||
it.trait_name = ref_map.get(getattr(it, "trait_id"))
|
||
|
||
async def descriptor_detail(self, id: int) -> DusDescriptorOutSchema:
|
||
obj = await DusDescriptorCRUD(self.auth, self.db).get(id=id)
|
||
if not obj:
|
||
raise CustomException(msg="该描述符不存在")
|
||
out = DusDescriptorOutSchema.model_validate(obj)
|
||
await self._attach_trait_labels([out])
|
||
return out
|
||
|
||
async def descriptor_get_list(
|
||
self,
|
||
search: DusDescriptorQueryParam | None = None,
|
||
order_by: list[dict[str, str]] | None = None,
|
||
) -> list[DusDescriptorOutSchema]:
|
||
obj_list = await DusDescriptorCRUD(self.auth, self.db).get_list(
|
||
search=search_to_dict(search), order_by=order_by
|
||
)
|
||
outs = [DusDescriptorOutSchema.model_validate(obj) for obj in obj_list]
|
||
await self._attach_trait_labels(outs)
|
||
return outs
|
||
|
||
async def descriptor_page(
|
||
self,
|
||
page_no: int,
|
||
page_size: int,
|
||
search: DusDescriptorQueryParam | None = None,
|
||
order_by: list[dict[str, str]] | None = None,
|
||
) -> PageResultSchema[DusDescriptorOutSchema]:
|
||
offset = (page_no - 1) * page_size
|
||
result = await DusDescriptorCRUD(self.auth, self.db).page(
|
||
offset=offset,
|
||
limit=page_size,
|
||
order_by=order_by or [{"id": "asc"}],
|
||
search=search_to_dict(search, {}),
|
||
out_schema=DusDescriptorOutSchema,
|
||
)
|
||
await self._attach_trait_labels(result.items)
|
||
return result
|
||
|
||
async def descriptor_create(self, data: DusDescriptorCreateSchema) -> DusDescriptorOutSchema:
|
||
await self._check_descriptor_no(data.descriptor_no)
|
||
await assert_parents_exist(self.db, [(TraitModel, data.trait_id, '性状字典')])
|
||
obj = await DusDescriptorCRUD(self.auth, self.db).create(data=data)
|
||
out = DusDescriptorOutSchema.model_validate(obj)
|
||
await self._attach_trait_labels([out])
|
||
return out
|
||
|
||
async def descriptor_update(self, id: int, data: DusDescriptorUpdateSchema) -> DusDescriptorOutSchema:
|
||
obj = await DusDescriptorCRUD(self.auth, self.db).get(id=id)
|
||
if not obj:
|
||
raise CustomException(msg="更新失败，该描述符不存在")
|
||
if not _is_blank(data.descriptor_no):
|
||
await self._check_descriptor_no(data.descriptor_no, exclude_id=id)
|
||
await assert_parents_exist(self.db, [(TraitModel, data.trait_id, '性状字典')])
|
||
obj = await DusDescriptorCRUD(self.auth, self.db).update(id=id, data=data)
|
||
out = DusDescriptorOutSchema.model_validate(obj)
|
||
await self._attach_trait_labels([out])
|
||
return out
|
||
|
||
async def descriptor_delete(self, ids: list[int]) -> None:
|
||
if not ids:
|
||
raise CustomException(msg="删除失败，删除对象不能为空")
|
||
objs = await DusDescriptorCRUD(self.auth, self.db).get_list(search={"id": ("in", ids)})
|
||
obj_map = {o.id: o for o in objs}
|
||
for id_ in ids:
|
||
if id_ not in obj_map:
|
||
raise CustomException(msg="删除失败，该描述符不存在")
|
||
await assert_no_children(self.db, ids, [(DusObservationModel, "dus_descriptor_id", "DUS观测")])
|
||
await DusDescriptorCRUD(self.auth, self.db).delete(ids=ids)
|
||
|
||
async def descriptor_list_options(self) -> list[dict[str, Any]]:
|
||
obj_list = await DusDescriptorCRUD(self.auth, self.db).get_list(order_by=[{"id": "asc"}])
|
||
return [{"value": o.id, "label": f"{o.descriptor_no} {o.descriptor_name}"} for o in obj_list]
|
||
|
||
@staticmethod
|
||
def descriptor_batch_export(obj_list: list[dict[str, Any]]) -> bytes:
|
||
mapping_dict = {
|
||
"descriptor_no": "描述符编号",
|
||
"descriptor_name": "特性中文名",
|
||
"trait_code": "关联性状编码",
|
||
"trait_name": "关联性状名称",
|
||
"expression_type": "表达类型",
|
||
"method": "测试方法",
|
||
"example_varieties": "标准/示例品种",
|
||
"test_stage": "测试生育期",
|
||
"required": "是否必测",
|
||
"remark": "备注",
|
||
"created_time": "创建时间",
|
||
"created_by": "创建者",
|
||
}
|
||
data = [dict(item) for item in obj_list]
|
||
for item in data:
|
||
creator = item.get("created_by")
|
||
item["created_by"] = creator.get("name", "未知") if isinstance(creator, dict) else "未知"
|
||
return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict)
|
||
|
||
async def descriptor_batch_import(self, file: UploadFile, update_support: bool = False) -> ImportResultSchema:
|
||
header_dict = {
|
||
"描述符编号": "descriptor_no",
|
||
"特性中文名": "descriptor_name",
|
||
"关联性状编码": "trait_code",
|
||
"表达类型": "expression_type",
|
||
"测试方法": "method",
|
||
"标准/示例品种": "example_varieties",
|
||
"测试生育期": "test_stage",
|
||
"是否必测": "required",
|
||
"备注": "remark",
|
||
}
|
||
try:
|
||
contents = await file.read()
|
||
rows = ExcelUtil.read_excel_to_dicts(contents)
|
||
await file.close()
|
||
if not rows:
|
||
raise CustomException(msg="导入文件为空")
|
||
missing_headers = [h for h in header_dict if h not in rows[0]]
|
||
if missing_headers:
|
||
raise CustomException(msg=f"导入文件缺少必要的列: {', '.join(missing_headers)}")
|
||
trait_rows = (await self.db.execute(select(TraitModel.trait_code, TraitModel.id))).all()
|
||
trait_map = {code: tid for code, tid in trait_rows}
|
||
error_msgs: list[str] = []
|
||
success_count = 0
|
||
crud = DusDescriptorCRUD(self.auth, self.db)
|
||
seen_nos: set[str] = set()
|
||
for i, row in enumerate(rows, start=1):
|
||
try:
|
||
no = row.get("descriptor_no")
|
||
if _is_blank(no):
|
||
raise CustomException(msg="描述符编号不能为空")
|
||
name = row.get("descriptor_name")
|
||
if _is_blank(name):
|
||
raise CustomException(msg="特性中文名不能为空")
|
||
no = str(no).strip()
|
||
if no in seen_nos:
|
||
raise CustomException(msg=f"文件内描述符编号重复：{no}")
|
||
seen_nos.add(no)
|
||
await self._check_descriptor_no(no)
|
||
trait_code = _none_if_blank(row.get("trait_code"))
|
||
trait_id = trait_map.get(str(trait_code)) if trait_code else None
|
||
fields = {
|
||
"descriptor_no": no,
|
||
"descriptor_name": str(name).strip(),
|
||
"trait_id": trait_id,
|
||
"trait_code": trait_code,
|
||
"expression_type": str(row.get("expression_type") or "QN").strip(),
|
||
"method": _none_if_blank(row.get("method")),
|
||
"example_varieties": _none_if_blank(row.get("example_varieties")),
|
||
"test_stage": _none_if_blank(row.get("test_stage")),
|
||
"required": str(row.get("required") or "1").strip(),
|
||
"remark": _none_if_blank(row.get("remark")),
|
||
}
|
||
await crud.create(data=DusDescriptorCreateSchema(**fields))
|
||
success_count += 1
|
||
except Exception as e:
|
||
error_msgs.append(f"第{i}行: {e!s}")
|
||
continue
|
||
return ImportResultSchema(
|
||
valid_count=success_count,
|
||
invalid_count=len(error_msgs),
|
||
message_list=error_msgs,
|
||
)
|
||
except Exception as e:
|
||
logger.error(f"批量导入描述符失败: {e!s}")
|
||
raise CustomException(msg=f"导入失败: {e!s}")
|
||
|
||
@staticmethod
|
||
def descriptor_import_template_download() -> bytes:
|
||
header_list = [
|
||
"描述符编号",
|
||
"特性中文名",
|
||
"关联性状编码",
|
||
"表达类型",
|
||
"测试方法",
|
||
"标准/示例品种",
|
||
"测试生育期",
|
||
"是否必测",
|
||
"备注",
|
||
]
|
||
return ExcelUtil.get_excel_template(
|
||
header_list=header_list,
|
||
selector_header_list=["表达类型", "是否必测"],
|
||
option_list=[{"表达类型": ["QN", "PQ", "QL"]}, {"是否必测": ["1", "0"]}],
|
||
)
|
||
|
||
# ---------- 测试记录 ----------
|
||
async def _check_test_name(self, name: str, exclude_id: int | None = None) -> None:
|
||
if _is_blank(name):
|
||
raise CustomException(msg="测试名称不能为空")
|
||
result = await self.db.execute(
|
||
select(DusTestModel.id).where(
|
||
DusTestModel.test_name == str(name).strip(),
|
||
DusTestModel.is_deleted.is_(False),
|
||
)
|
||
)
|
||
obj_id = result.scalar_one_or_none()
|
||
if obj_id is not None and obj_id != exclude_id:
|
||
raise CustomException(msg=f"测试名称 {name} 已存在", status_code=409)
|
||
|
||
async def _attach_test_labels(self, items: list[DusTestOutSchema]) -> None:
|
||
if not items:
|
||
return
|
||
germ_ids = {getattr(it, "germplasm_id") for it in items if getattr(it, "germplasm_id")}
|
||
trial_ids = {getattr(it, "trial_study_id") for it in items if getattr(it, "trial_study_id")}
|
||
if germ_ids:
|
||
rows = (await self.db.execute(
|
||
select(BreedingGermplasmModel.id, BreedingGermplasmModel.cultivar_name).where(
|
||
BreedingGermplasmModel.id.in_(germ_ids)
|
||
)
|
||
)).all()
|
||
ref_map = {rid: name for rid, name in rows}
|
||
for it in items:
|
||
it.germplasm_name = ref_map.get(getattr(it, "germplasm_id"))
|
||
if trial_ids:
|
||
rows = (await self.db.execute(
|
||
select(TrialStudyModel.id, TrialStudyModel.study_name).where(
|
||
TrialStudyModel.id.in_(trial_ids)
|
||
)
|
||
)).all()
|
||
ref_map = {rid: name for rid, name in rows}
|
||
for it in items:
|
||
it.trial_study_name = ref_map.get(getattr(it, "trial_study_id"))
|
||
|
||
async def test_detail(self, id: int) -> DusTestOutSchema:
|
||
obj = await DusTestCRUD(self.auth, self.db).get(id=id)
|
||
if not obj:
|
||
raise CustomException(msg="该测试记录不存在")
|
||
out = DusTestOutSchema.model_validate(obj)
|
||
await self._attach_test_labels([out])
|
||
return out
|
||
|
||
async def test_get_list(
|
||
self,
|
||
search: DusTestQueryParam | None = None,
|
||
order_by: list[dict[str, str]] | None = None,
|
||
) -> list[DusTestOutSchema]:
|
||
obj_list = await DusTestCRUD(self.auth, self.db).get_list(
|
||
search=search_to_dict(search), order_by=order_by
|
||
)
|
||
outs = [DusTestOutSchema.model_validate(obj) for obj in obj_list]
|
||
await self._attach_test_labels(outs)
|
||
return outs
|
||
|
||
async def test_page(
|
||
self,
|
||
page_no: int,
|
||
page_size: int,
|
||
search: DusTestQueryParam | None = None,
|
||
order_by: list[dict[str, str]] | None = None,
|
||
) -> PageResultSchema[DusTestOutSchema]:
|
||
offset = (page_no - 1) * page_size
|
||
result = await DusTestCRUD(self.auth, self.db).page(
|
||
offset=offset,
|
||
limit=page_size,
|
||
order_by=order_by or [{"id": "asc"}],
|
||
search=search_to_dict(search, {}),
|
||
out_schema=DusTestOutSchema,
|
||
)
|
||
await self._attach_test_labels(result.items)
|
||
return result
|
||
|
||
async def test_create(self, data: DusTestCreateSchema) -> DusTestOutSchema:
|
||
await self._check_test_name(data.test_name)
|
||
await assert_parents_exist(self.db, [
|
||
(BreedingGermplasmModel, data.germplasm_id, '申请品种'),
|
||
(TrialStudyModel, data.trial_study_id, '测试点'),
|
||
])
|
||
obj = await DusTestCRUD(self.auth, self.db).create(data=data)
|
||
out = DusTestOutSchema.model_validate(obj)
|
||
await self._attach_test_labels([out])
|
||
return out
|
||
|
||
async def test_update(self, id: int, data: DusTestUpdateSchema) -> DusTestOutSchema:
|
||
obj = await DusTestCRUD(self.auth, self.db).get(id=id)
|
||
if not obj:
|
||
raise CustomException(msg="更新失败，该测试记录不存在")
|
||
if not _is_blank(data.test_name):
|
||
await self._check_test_name(data.test_name, exclude_id=id)
|
||
await assert_parents_exist(self.db, [
|
||
(BreedingGermplasmModel, data.germplasm_id, '申请品种'),
|
||
(TrialStudyModel, data.trial_study_id, '测试点'),
|
||
])
|
||
obj = await DusTestCRUD(self.auth, self.db).update(id=id, data=data)
|
||
out = DusTestOutSchema.model_validate(obj)
|
||
await self._attach_test_labels([out])
|
||
return out
|
||
|
||
async def test_delete(self, ids: list[int]) -> None:
|
||
if not ids:
|
||
raise CustomException(msg="删除失败，删除对象不能为空")
|
||
objs = await DusTestCRUD(self.auth, self.db).get_list(search={"id": ("in", ids)})
|
||
obj_map = {o.id: o for o in objs}
|
||
for id_ in ids:
|
||
if id_ not in obj_map:
|
||
raise CustomException(msg="删除失败，该测试记录不存在")
|
||
await assert_no_children(self.db, ids, [(DusObservationModel, "dus_test_id", "DUS观测")])
|
||
await DusTestCRUD(self.auth, self.db).delete(ids=ids)
|
||
|
||
async def test_list_options(self) -> list[dict[str, Any]]:
|
||
obj_list = await DusTestCRUD(self.auth, self.db).get_list(order_by=[{"id": "asc"}])
|
||
return [{"value": o.id, "label": o.test_name} for o in obj_list]
|
||
|
||
@staticmethod
|
||
def test_batch_export(obj_list: list[dict[str, Any]]) -> bytes:
|
||
mapping_dict = {
|
||
"test_name": "测试名称",
|
||
"germplasm_name": "申请品种",
|
||
"trial_study_name": "测试点",
|
||
"tester": "测试人",
|
||
"test_date": "测试日期",
|
||
"status": "状态",
|
||
"conclusion": "结论",
|
||
"report_path": "报告附件",
|
||
"remark": "备注",
|
||
"created_time": "创建时间",
|
||
"created_by": "创建者",
|
||
}
|
||
data = [dict(item) for item in obj_list]
|
||
for item in data:
|
||
creator = item.get("created_by")
|
||
item["created_by"] = creator.get("name", "未知") if isinstance(creator, dict) else "未知"
|
||
return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict)
|
||
|
||
# ---------- 观测 ----------
|
||
async def _check_observation_dup(
|
||
self, dus_test_id: int | None, dus_descriptor_id: int | None, exclude_id: int | None = None
|
||
) -> None:
|
||
if dus_test_id is None or dus_descriptor_id is None:
|
||
return
|
||
conditions = [
|
||
DusObservationModel.dus_test_id == dus_test_id,
|
||
DusObservationModel.dus_descriptor_id == dus_descriptor_id,
|
||
DusObservationModel.is_deleted.is_(False),
|
||
]
|
||
if exclude_id is not None:
|
||
conditions.append(DusObservationModel.id != exclude_id)
|
||
result = await self.db.execute(select(func.count()).select_from(DusObservationModel).where(*conditions))
|
||
if result.scalar() or 0:
|
||
raise CustomException(msg="该(测试,描述符)观测已存在", status_code=409)
|
||
|
||
async def _attach_descriptor_labels(self, items: list[DusObservationOutSchema]) -> None:
|
||
ids = {getattr(it, "dus_descriptor_id") for it in items if getattr(it, "dus_descriptor_id")}
|
||
if not ids:
|
||
return
|
||
rows = (await self.db.execute(
|
||
select(DusDescriptorModel.id, DusDescriptorModel.descriptor_no, DusDescriptorModel.descriptor_name).where(
|
||
DusDescriptorModel.id.in_(ids)
|
||
)
|
||
)).all()
|
||
ref_map = {rid: (no, name) for rid, no, name in rows}
|
||
for it in items:
|
||
pair = ref_map.get(getattr(it, "dus_descriptor_id"))
|
||
if pair:
|
||
it.descriptor_no, it.descriptor_name = pair
|
||
|
||
async def observation_detail(self, id: int) -> DusObservationOutSchema:
|
||
obj = await DusObservationCRUD(self.auth, self.db).get(id=id)
|
||
if not obj:
|
||
raise CustomException(msg="该观测不存在")
|
||
out = DusObservationOutSchema.model_validate(obj)
|
||
await self._attach_descriptor_labels([out])
|
||
return out
|
||
|
||
async def observation_get_list(
|
||
self,
|
||
search: DusObservationQueryParam | None = None,
|
||
order_by: list[dict[str, str]] | None = None,
|
||
) -> list[DusObservationOutSchema]:
|
||
obj_list = await DusObservationCRUD(self.auth, self.db).get_list(
|
||
search=search_to_dict(search), order_by=order_by
|
||
)
|
||
outs = [DusObservationOutSchema.model_validate(obj) for obj in obj_list]
|
||
await self._attach_descriptor_labels(outs)
|
||
return outs
|
||
|
||
async def observation_page(
|
||
self,
|
||
page_no: int,
|
||
page_size: int,
|
||
search: DusObservationQueryParam | None = None,
|
||
order_by: list[dict[str, str]] | None = None,
|
||
) -> PageResultSchema[DusObservationOutSchema]:
|
||
offset = (page_no - 1) * page_size
|
||
result = await DusObservationCRUD(self.auth, self.db).page(
|
||
offset=offset,
|
||
limit=page_size,
|
||
order_by=order_by or [{"id": "asc"}],
|
||
search=search_to_dict(search, {}),
|
||
out_schema=DusObservationOutSchema,
|
||
)
|
||
await self._attach_descriptor_labels(result.items)
|
||
return result
|
||
|
||
async def observation_create(self, data: DusObservationCreateSchema) -> DusObservationOutSchema:
|
||
await self._check_observation_dup(data.dus_test_id, data.dus_descriptor_id)
|
||
await assert_parents_exist(self.db, [
|
||
(DusTestModel, data.dus_test_id, 'DUS测试'),
|
||
(DusDescriptorModel, data.dus_descriptor_id, '描述符'),
|
||
])
|
||
obj = await DusObservationCRUD(self.auth, self.db).create(data=data)
|
||
out = DusObservationOutSchema.model_validate(obj)
|
||
await self._attach_descriptor_labels([out])
|
||
return out
|
||
|
||
async def observation_update(self, id: int, data: DusObservationUpdateSchema) -> DusObservationOutSchema:
|
||
obj = await DusObservationCRUD(self.auth, self.db).get(id=id)
|
||
if not obj:
|
||
raise CustomException(msg="更新失败，该观测不存在")
|
||
await self._check_observation_dup(data.dus_test_id, data.dus_descriptor_id, exclude_id=id)
|
||
await assert_parents_exist(self.db, [
|
||
(DusTestModel, data.dus_test_id, 'DUS测试'),
|
||
(DusDescriptorModel, data.dus_descriptor_id, '描述符'),
|
||
])
|
||
obj = await DusObservationCRUD(self.auth, self.db).update(id=id, data=data)
|
||
out = DusObservationOutSchema.model_validate(obj)
|
||
await self._attach_descriptor_labels([out])
|
||
return out
|
||
|
||
async def observation_delete(self, ids: list[int]) -> None:
|
||
if not ids:
|
||
raise CustomException(msg="删除失败，删除对象不能为空")
|
||
objs = await DusObservationCRUD(self.auth, self.db).get_list(search={"id": ("in", ids)})
|
||
obj_map = {o.id: o for o in objs}
|
||
for id_ in ids:
|
||
if id_ not in obj_map:
|
||
raise CustomException(msg="删除失败，该观测不存在")
|
||
await DusObservationCRUD(self.auth, self.db).delete(ids=ids)
|
||
|
||
@staticmethod
|
||
def observation_batch_export(obj_list: list[dict[str, Any]]) -> bytes:
|
||
mapping_dict = {
|
||
"descriptor_no": "描述符编号",
|
||
"descriptor_name": "特性名称",
|
||
"value_numeric": "数值表达值",
|
||
"value_text": "文本表达值",
|
||
"expression_note": "表达说明",
|
||
"remark": "备注",
|
||
"created_time": "创建时间",
|
||
"created_by": "创建者",
|
||
}
|
||
data = [dict(item) for item in obj_list]
|
||
for item in data:
|
||
creator = item.get("created_by")
|
||
item["created_by"] = creator.get("name", "未知") if isinstance(creator, dict) else "未知"
|
||
return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict)
|
||
|
||
# ---------- 特异性统计判定（§8.18） ----------
|
||
async def test_distinctness(
|
||
self,
|
||
test_id: int,
|
||
reference_test_ids: list[int] | None = None,
|
||
alpha: float = 0.01,
|
||
) -> dict[str, Any]:
|
||
test = await DusTestCRUD(self.auth, self.db).get(id=test_id)
|
||
if not test:
|
||
raise CustomException(msg="该测试记录不存在")
|
||
if reference_test_ids:
|
||
ref_ids = [rid for rid in reference_test_ids if rid != test_id]
|
||
if not ref_ids:
|
||
raise CustomException(msg="参照测试不能为空或与候选相同")
|
||
ref_objs = await DusTestCRUD(self.auth, self.db).get_list(search={"id": ("in", ref_ids)})
|
||
ref_map = {r.id: r for r in ref_objs}
|
||
missing = [rid for rid in ref_ids if rid not in ref_map]
|
||
if missing:
|
||
raise CustomException(msg=f"参照测试不存在: {missing}")
|
||
else:
|
||
if test.trial_study_id is None:
|
||
raise CustomException(
|
||
msg="候选测试未指定测试点，无法自动选取参照；请显式传入 reference_test_ids"
|
||
)
|
||
ref_objs = await DusTestCRUD(self.auth, self.db).get_list(
|
||
search={"trial_study_id": test.trial_study_id}
|
||
)
|
||
ref_objs = [r for r in ref_objs if r.id != test_id]
|
||
if not ref_objs:
|
||
raise CustomException(msg="同一测试点无其他测试可作参照")
|
||
|
||
all_ids = [test_id] + [r.id for r in ref_objs]
|
||
obs_rows = (await self.db.execute(
|
||
select(
|
||
DusObservationModel.dus_test_id,
|
||
DusObservationModel.dus_descriptor_id,
|
||
DusObservationModel.value_numeric,
|
||
DusObservationModel.value_text,
|
||
).where(
|
||
DusObservationModel.dus_test_id.in_(all_ids),
|
||
DusObservationModel.is_deleted.is_(False),
|
||
)
|
||
)).all()
|
||
by_test: dict[int, list[dict[str, Any]]] = defaultdict(list)
|
||
for row in obs_rows:
|
||
by_test[row.dus_test_id].append({
|
||
"dus_descriptor_id": row.dus_descriptor_id,
|
||
"value_numeric": row.value_numeric,
|
||
"value_text": row.value_text,
|
||
})
|
||
|
||
# 品种分组：同 germplasm_id 的多个测试视为同一品种组的重复观测（跨年/多点）
|
||
cand_key: Any = test.germplasm_id if test.germplasm_id is not None else f"self{test_id}"
|
||
group_obs: dict[Any, dict[int, dict[str, list[Any]]]] = {}
|
||
_merge_obs(group_obs.setdefault(cand_key, {}), by_test.get(test_id, []))
|
||
for ro in ref_objs:
|
||
key: Any = ro.germplasm_id if ro.germplasm_id is not None else f"t{ro.id}"
|
||
if key == cand_key:
|
||
_merge_obs(group_obs[cand_key], by_test.get(ro.id, []))
|
||
else:
|
||
_merge_obs(group_obs.setdefault(key, {}), by_test.get(ro.id, []))
|
||
|
||
candidate = group_obs[cand_key]
|
||
references = [group_obs[k] for k in group_obs if k != cand_key]
|
||
if not references:
|
||
raise CustomException(msg="参照测试均为候选同品种，无法构成参照集")
|
||
|
||
all_dids = set(candidate) | {did for ref in references for did in ref}
|
||
descriptor_meta: dict[int, dict[str, Any]] = {}
|
||
if all_dids:
|
||
desc_rows = (await self.db.execute(
|
||
select(
|
||
DusDescriptorModel.id,
|
||
DusDescriptorModel.descriptor_no,
|
||
DusDescriptorModel.descriptor_name,
|
||
DusDescriptorModel.expression_type,
|
||
DusDescriptorModel.required,
|
||
).where(DusDescriptorModel.id.in_(all_dids))
|
||
)).all()
|
||
descriptor_meta = {
|
||
row.id: {
|
||
"descriptor_no": row.descriptor_no,
|
||
"descriptor_name": row.descriptor_name,
|
||
"expression_type": row.expression_type,
|
||
"required": row.required,
|
||
}
|
||
for row in desc_rows
|
||
}
|
||
if not descriptor_meta:
|
||
raise CustomException(msg="候选与参照均无观测数据，无法判定")
|
||
|
||
report = distinctness(candidate, references, descriptor_meta, alpha=alpha)
|
||
report["candidate_test_id"] = test_id
|
||
report["reference_test_ids"] = [r.id for r in ref_objs]
|
||
report["ran_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||
|
||
conclusion = test.conclusion
|
||
if report["suggestion"] in ("distinct", "not_distinct") and conclusion in (None, "", "pending"):
|
||
conclusion = report["suggestion"]
|
||
data: dict[str, Any] = {"analysis_json": report}
|
||
if conclusion != test.conclusion:
|
||
data["conclusion"] = conclusion
|
||
await DusTestCRUD(self.auth, self.db).update(id=test_id, data=data)
|
||
return report
|
||
|
||
async def distinctness_report(self, test_id: int) -> dict[str, Any]:
|
||
test = await DusTestCRUD(self.auth, self.db).get(id=test_id)
|
||
if not test:
|
||
raise CustomException(msg="该测试记录不存在")
|
||
if not test.analysis_json:
|
||
raise CustomException(msg="该测试尚未运行特异性判定（POST /bre/dus_test/distinctness/{id}）")
|
||
return test.analysis_json
|