perf(plans): resolve project identity once per validation pass

This commit is contained in:
阿白叔 committed 2026-10-15 22:00:20 +08:00
1 parent 224f4e7c1e
commit b3883cfca1
5 files changed
+83 -30

No files matched your search

@@ -9,7 +9,7 @@ from .bom_batch import BomBatchPreview, BomProjectPreview, _assert_editable, _id
from .bom_plan import BomMatcher, _normal_headers, _text, parse_bom_row
from .errors import TaskCenterError
from .store_target_plan import merge_target_inventory
from .target_plan import compile_target_rules
from .target_plan import ProjectIdentityResolver, compile_target_rules
@dataclass(frozen=True)
@@ -92,7 +92,8 @@ def inspect_batch(service, task_id, path, *, stop_event=None, on_progress=None):
check_cancelled()
scope = _scope(service._store, task_id)
owners = {str(project.path.resolve()).casefold(): (task, project) for task, project in scope}
routing = ProjectIdentityResolver()
owners = {routing.project(project.path): (task, project) for task, project in scope}
if len(owners) != len(scope):
raise TaskCenterError('project_binding', '同批任务存在重复工程')
rows, records, grouped = [], {}, {}
@@ -123,7 +124,7 @@ def inspect_batch(service, task_id, path, *, stop_event=None, on_progress=None):
project_path = _text(values, positions, 'project_path')
project_name = _text(values, positions, 'project_name')
if project_path:
owner = owners.get(str(Path(project_path).resolve()).casefold())
owner = owners.get(routing.project(project_path))
if owner is not None:
project_path, project_name = str(owner[1].path), owner[0].name
elif len(scope) == 1:
@@ -142,7 +143,7 @@ def inspect_batch(service, task_id, path, *, stop_event=None, on_progress=None):
if not record.project_path and len(scope) != 1:
reason = '多工程 BOM 必须填写工程路径列,不能按位号猜测工程'
else:
key = str(Path(record.project_path).resolve()).casefold() if record.project_path else next(iter(owners))
key = routing.project(record.project_path) if record.project_path else next(iter(owners))
if key not in owners:
reason = f'BOM 工程不属于当前批次:{record.project_path}'
else:
@@ -12,7 +12,7 @@ from openpyxl.styles import Alignment, Font, PatternFill
from openpyxl.worksheet.datavalidation import DataValidation
from .errors import TaskCenterError
from .target_plan import TargetPlanRow, compile_target_rules
from .target_plan import ProjectIdentityResolver, TargetPlanRow, compile_target_rules
BOM_HEADERS = ('project_name', 'project_path', 'old_part_number', 'new_part_number', 'refdes', 'schematic_name',
@@ -158,9 +158,10 @@ class BomMatcher:
self.by_key = {}
self.projects = set()
self.by_identity = {}
self.identities = ProjectIdentityResolver()
for row in baseline:
target = row.target
key = target.key
key = self.identities.target(target)
if key in self.by_key:
raise TaskCenterError('target_overlap', '采集清单存在重复位号身份')
self.by_key[key] = row
@@ -168,7 +169,7 @@ class BomMatcher:
self.by_identity.setdefault((target.old_part_number.casefold(), target.refdes.casefold()), []).append((key, target))
def match_record(self, record):
if record.project_path and str(Path(record.project_path).resolve()).casefold() not in self.projects:
if record.project_path and self.identities.project(record.project_path) not in self.projects:
raise TaskCenterError('bom_import', 'BOM 工程与当前任务不一致')
matched = {}
for refdes in record.refs:
@@ -4,24 +4,26 @@ from __future__ import annotations
from pathlib import Path
from .errors import TaskCenterError
from .models import TaskRecord, TaskStatus
from .target_plan import ProjectIdentityResolver
def _target_baseline(target) -> tuple:
return (target.key, target.refdes, target.old_part_number, target.old_value)
def _target_baseline(target, identities) -> tuple:
return (identities.target(target), target.refdes, target.old_part_number, target.old_value)
def merge_target_inventory(existing, targets) -> tuple:
"""Validate an additive inventory snapshot and retain every existing edit."""
from .target_plan import TargetPlanRow
existing, targets = tuple(existing), tuple(targets)
incoming = {target.key: target for target in targets}
identities = ProjectIdentityResolver()
incoming = {identities.target(target): target for target in targets}
if len(incoming) != len(targets):
raise TaskCenterError("target_identity", "component inventory contains duplicate UID")
if any(row.target.key not in incoming or
_target_baseline(row.target) != _target_baseline(incoming[row.target.key])
if any(identities.target(row.target) not in incoming or
_target_baseline(row.target, identities) != _target_baseline(incoming[identities.target(row.target)], identities)
for row in existing):
raise TaskCenterError("target_identity", "component inventory identity changed")
known = {row.target.key for row in existing}
return existing + tuple(TargetPlanRow(target) for target in targets if target.key not in known)
known = {identities.target(row.target) for row in existing}
return existing + tuple(TargetPlanRow(target) for key, target in incoming.items() if key not in known)
class TargetPlanRepository:
@@ -68,22 +70,24 @@ class TargetPlanRepository:
raise TaskCenterError("target_plan_locked", "task plan is locked")
rows = tuple(rows)
compile_target_rules(rows)
identities = ProjectIdentityResolver()
projects = self._store.list_projects(task_id)
allowed = {str(project.path.resolve(strict=False)).casefold() for project in projects}
if any(str(row.target.project_path.resolve(strict=False)).casefold() not in allowed for row in rows):
allowed = {identities.project(project.path) for project in projects}
if any(identities.project(row.target.project_path) not in allowed for row in rows):
raise TaskCenterError("target_identity", "target project is not in task")
inventory = {row.target.key: row.target for row in self._store.list_target_plan(task_id)}
inventory = {identities.target(row.target): row.target for row in self._store.list_target_plan(task_id)}
if not inventory and not (task.target_plan_mode and not rows):
raise TaskCenterError("target_inventory", "collect component inventory before editing the plan")
if set(inventory) != {row.target.key for row in rows} or any(
_target_baseline(inventory[row.target.key]) != _target_baseline(row.target)
keys = {identities.target(row.target) for row in rows}
if len(keys) != len(rows) or set(inventory) != keys or any(
_target_baseline(inventory[identities.target(row.target)], identities) != _target_baseline(row.target, identities)
for row in rows):
raise TaskCenterError("target_identity", "target baseline identity changed")
self._store._connection.execute("DELETE FROM target_plan WHERE task_id = ?", (task_id,))
for row in rows:
target = row.target
self._store._connection.execute("""INSERT INTO target_plan VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
(task_id, str(target.project_path.resolve(strict=False)).casefold(), target.schematic_name,
(task_id, identities.project(target.project_path), target.schematic_name,
target.sheet_number, target.uid, target.refdes, target.old_part_number, target.old_value,
int(row.enabled), row.new_part_number, int(row.custom_value_enabled), row.custom_value,
int(row.sync_nc)))
@@ -103,16 +107,16 @@ class TargetPlanRepository:
return ()
existing = self._store.list_target_plan(task_id)
merged = merge_target_inventory(existing, targets)
known = {row.target.key for row in existing}
rows = tuple(row for row in merged if row.target.key not in known)
rows = merged[len(existing):]
identities = ProjectIdentityResolver()
projects = self._store.list_projects(task_id)
allowed = {str(project.path.resolve(strict=False)).casefold() for project in projects}
if any(str(row.target.project_path.resolve(strict=False)).casefold() not in allowed for row in rows):
allowed = {identities.project(project.path) for project in projects}
if any(identities.project(row.target.project_path) not in allowed for row in rows):
raise TaskCenterError("target_identity", "inventory project is not in task")
for row in rows:
target = row.target
self._store._connection.execute("""INSERT INTO target_plan VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, '', 0, '', 1)""",
(task_id, str(target.project_path.resolve(strict=False)).casefold(), target.schematic_name,
(task_id, identities.project(target.project_path), target.schematic_name,
target.sheet_number, target.uid, target.refdes, target.old_part_number, target.old_value))
self._store._connection.execute("UPDATE tasks SET target_plan_mode = 1 WHERE task_id = ?", (task_id,))
return self._store.list_target_plan(task_id)
@@ -8,6 +8,21 @@ from pathlib import Path
from .errors import TaskCenterError
class ProjectIdentityResolver:
"""Resolve each project once within one validation pass, never across passes."""
def __init__(self):
self._projects = {}
def project(self, path):
spelling = str(path)
if spelling not in self._projects:
self._projects[spelling] = str(Path(path).resolve(strict=False)).casefold()
return self._projects[spelling]
def target(self, target):
return (self.project(target.project_path), target.schematic_name, target.sheet_number, target.uid)
@dataclass(frozen=True, slots=True)
class ComponentTarget:
project_path: Path
@@ -27,8 +42,7 @@ class ComponentTarget:
@property
def key(self) -> tuple[str, str, str, str]:
return (str(self.project_path.resolve(strict=False)).casefold(),
self.schematic_name, self.sheet_number, self.uid)
return ProjectIdentityResolver().target(self)
@dataclass(frozen=True, slots=True)
@@ -77,14 +91,16 @@ def compile_target_rules(rows: tuple[TargetPlanRow, ...]) -> tuple[TargetRule, .
grouped: dict[tuple[str, str, str, str, str, str, bool, str, bool], list[ComponentTarget]] = {}
old_parts: set[str] = set()
new_parts: set[str] = set()
identities = ProjectIdentityResolver()
for row in rows:
target = row.target
if not all((target.uid, target.refdes, target.schematic_name, target.sheet_number,
target.old_part_number)):
raise TaskCenterError("target_identity", "component identity is incomplete")
if target.key in seen:
target_key = identities.target(target)
if target_key in seen:
raise TaskCenterError("target_overlap", "target UID appears more than once")
seen.add(target.key)
seen.add(target_key)
if not row.enabled:
continue
new = row.new_part_number.strip()
@@ -95,7 +111,7 @@ def compile_target_rules(rows: tuple[TargetPlanRow, ...]) -> tuple[TargetRule, .
raise TaskCenterError("value_option", "custom Value is empty")
old_parts.add(old.casefold())
new_parts.add(new.casefold())
key = (str(target.project_path.resolve(strict=False)).casefold(), target.schematic_name,
key = (target_key[0], target.schematic_name,
target.sheet_number, old, new, row.custom_value_enabled,
row.custom_value if row.custom_value_enabled else "", row.sync_nc)
grouped.setdefault(key, []).append(target)
+31
View File
@@ -0,0 +1,31 @@
from pathlib import Path
import pytest
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow, compile_target_rules
from dx_productivity.trial_task_center.store_target_plan import merge_target_inventory
@pytest.mark.parametrize('operation', ['compile', 'merge'])
def test_plan_operations_resolve_each_project_once_and_refresh_next_call(tmp_path, monkeypatch, operation):
projects = (tmp_path / 'one.prj', tmp_path / 'two.prj')
rows = tuple(TargetPlanRow(ComponentTarget(path, 'MAIN', '1', f'u{i}', f'R{i}', 'OLD', 'V'), True, 'NEW')
for path in projects for i in range(20))
original = Path.resolve
resolved = []
def resolve(path, *args, **kwargs):
resolved.append(str(path))
return original(path, *args, **kwargs)
monkeypatch.setattr(Path, 'resolve', resolve)
def run():
if operation == 'compile':
rules = compile_target_rules(rows)
assert len(rules) == 2
assert sum(len(rule.targets) for rule in rules) == 40
else:
assert merge_target_inventory(rows, tuple(row.target for row in rows)) == rows
run()
assert len(resolved) == 2
resolved.clear()
run()
assert len(resolved) == 2, 'a later operation must resolve project identity again'