diff --git a/src/dx_productivity/trial_task_center/bom_import_report.py b/src/dx_productivity/trial_task_center/bom_import_report.py index 2f4c48a..4a4d363 100644 --- a/src/dx_productivity/trial_task_center/bom_import_report.py +++ b/src/dx_productivity/trial_task_center/bom_import_report.py @@ -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: diff --git a/src/dx_productivity/trial_task_center/bom_plan.py b/src/dx_productivity/trial_task_center/bom_plan.py index 96b323a..2404e56 100644 --- a/src/dx_productivity/trial_task_center/bom_plan.py +++ b/src/dx_productivity/trial_task_center/bom_plan.py @@ -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: diff --git a/src/dx_productivity/trial_task_center/store_target_plan.py b/src/dx_productivity/trial_task_center/store_target_plan.py index 8cac1fc..e3fc8a0 100644 --- a/src/dx_productivity/trial_task_center/store_target_plan.py +++ b/src/dx_productivity/trial_task_center/store_target_plan.py @@ -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) diff --git a/src/dx_productivity/trial_task_center/target_plan.py b/src/dx_productivity/trial_task_center/target_plan.py index 24555f2..71e8d0e 100644 --- a/src/dx_productivity/trial_task_center/target_plan.py +++ b/src/dx_productivity/trial_task_center/target_plan.py @@ -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) diff --git a/tests/v1_1/test_plan_identity_cost.py b/tests/v1_1/test_plan_identity_cost.py new file mode 100644 index 0000000..1021e42 --- /dev/null +++ b/tests/v1_1/test_plan_identity_cost.py @@ -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'