Reuse supervised project sessions between verified replacement steps

This commit is contained in:
阿白叔 committed 2026-10-15 10:37:37 +08:00
1 parent 4194c011e3
commit 2172d8faee
9 files changed
+754 -80

No files matched your search

+166 -16
View File
@@ -32,6 +32,9 @@ Dim QP_BatchSaveCommitted
Dim QP_DiscoveryMode, QP_TargetSchematic, QP_TargetSheet
Dim QP_FailureNumber, QP_FailureSource, QP_FailureDescription
Dim QP_NcSyncSummary
Dim QP_SessionMode, QP_SessionToken, QP_SessionProject, QP_MonitorJobId
Dim QP_OwnedProjectPath, QP_SessionWaiting, QP_SessionExternalChange
Dim QP_CheckpointSchematic, QP_CheckpointSheet
Dim FailureState, CloseError
Set QP_Fso = CreateObject("Scripting.FileSystemObject")
QP_RootTemplate = "%LOCALAPPDATA%\DxProductivity\trial-task-center\quick-run"
@@ -67,6 +70,11 @@ QP_ComponentIndexContext = ""
QP_CurrentJobId = ""
QP_ExitCode = 0
QP_Stage = "session_startup"
QP_SessionMode = False
QP_OwnedProjectPath = ""
QP_SessionWaiting = False
QP_SessionExternalChange = False
QP_MonitorJobId = QP_ExpectedJobId
Set QP_App = Nothing
On Error Resume Next
@@ -86,8 +94,14 @@ Else
If QP_DiscoveryMode Then
QPDiscoverSheets
Else
QPMain
If Err.Number = 0 And QP_BatchMode Then QPFinishBatchItem
Do
QPMain
If Err.Number <> 0 Then Exit Do
If QP_BatchMode Then QPFinishBatchItem
If Err.Number <> 0 Or Not QP_SessionMode Then Exit Do
QPSessionNext
If Err.Number <> 0 Or Not QP_SessionMode Then Exit Do
Loop
End If
If Err.Number <> 0 Then
QP_FailureNumber = Err.Number
@@ -96,7 +110,7 @@ Else
If QP_DiscoveryMode Then QPCleanupDiscoveryFailure
FailureState = "hard_failure"
CloseError = ""
If QP_BatchMode Then
If QP_BatchMode Or QP_SessionMode Then
QPDiscardFailedBatchProject CloseError
If Len(CloseError) = 0 Then
If QP_BatchSaveCommitted Then
@@ -173,6 +187,7 @@ Sub QPBootstrapSession()
Err.Raise vbObjectError + 872, "QuickPartReplace.Discovery", "sheet discovery authorization does not match this job"
QP_DiscoveryMode = True
End If
QPReadSessionRequest
QPProgress "session_startup", 0, 0
TargetPath = QPConfirmedProjectPath()
If QP_Fso.FileExists(QP_Fso.BuildPath(QP_Root, "recovery.request")) Then
@@ -184,6 +199,7 @@ Sub QPBootstrapSession()
Set QP_App = GetObject(, "Viewdraw.Application")
Else
Set QP_App = QPAttachOrStart(QPDesignerProcessCount())
If QP_SessionMode Then WScript.ConnectObject QP_App, "QPEvent_"
QPEnsureProject QP_App, TargetPath
End If
QP_Stage = "session_ready"
@@ -193,7 +209,9 @@ End Sub
Sub QPCleanupDiscoveryFailure()
On Error Resume Next
If QP_OwnedProject And Not QP_App Is Nothing Then QP_App.CloseProject
If QP_OwnedProject And Not QP_App Is Nothing Then
If QPCanonicalPath(QPProjectPath()) = QPCanonicalPath(QP_OwnedProjectPath) Then QP_App.CloseProject
End If
QP_OwnedProject = False
Err.Clear
On Error GoTo 0
@@ -220,15 +238,21 @@ Sub QPWaitForMonitor()
End Sub
Sub QPProgress(ByVal Stage, ByVal Done, ByVal Total)
Dim Safe, StopPath
Dim Safe, StopPath, Job, Suffix
If Len(CStr(QP_AttemptToken)) = 0 Then Exit Sub
Safe = 0
If Not CBool(QP_NativeMutationPossible) And Not CBool(QP_RestoreTransactionOpen) And _
Not CBool(QP_NativeCallActive) Then Safe = 1
QP_ProgressSequence = CLng(QP_ProgressSequence) + 1
Job = QP_ExpectedJobId
Suffix = ""
If QP_SessionMode Then
Job = QP_MonitorJobId
Suffix = vbTab & QP_ExpectedJobId
End If
WScript.StdOut.WriteLine "DX_PROGRESS" & vbTab & QP_AttemptToken & vbTab & _
QP_ExpectedJobId & vbTab & CStr(QP_ProgressSequence) & vbTab & Stage & _
vbTab & CStr(Done) & vbTab & CStr(Total) & vbTab & CStr(Safe)
Job & vbTab & CStr(QP_ProgressSequence) & vbTab & Stage & _
vbTab & CStr(Done) & vbTab & CStr(Total) & vbTab & CStr(Safe) & Suffix
If Safe = 1 And Stage <> "finished" Then
StopPath = QP_Fso.BuildPath(QP_Root, "monitor-" & QP_AttemptToken & ".stop")
If QP_Fso.FileExists(StopPath) Then
@@ -239,6 +263,111 @@ Sub QPProgress(ByVal Stage, ByVal Done, ByVal Total)
End If
End Sub
Sub QPReadSessionRequest()
Dim Path, Fields, Index, Character
Path = QP_Fso.BuildPath(QP_Root, "project-session.request")
If Not QP_Fso.FileExists(Path) Then Exit Sub
If Not QP_BatchMode Or QP_DiscoveryMode Or _
QP_Fso.FileExists(QP_Fso.BuildPath(QP_Root, "recovery.request")) Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "invalid project session mode"
Fields = Split(Trim(QPReadUtf8(Path)), vbTab)
If UBound(Fields) <> 2 Then Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "invalid session request"
QP_SessionToken = CStr(Fields(0))
If Len(QP_SessionToken) <> 32 Or Fields(2) <> QP_ExpectedJobId Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "session authorization mismatch"
For Index = 1 To 32
Character = Mid(QP_SessionToken, Index, 1)
If InStr(1, "0123456789abcdef", Character, vbBinaryCompare) = 0 Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "invalid session token"
Next
QP_SessionProject = CStr(Fields(1))
If QPCanonicalPath(QPConfirmedProjectPath()) <> QPCanonicalPath(QP_SessionProject) Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "session project mismatch"
QP_SessionMode = True
End Sub
Sub QPSessionNext()
Dim Path, Fields, Attempt, TargetPath, Documents, Document, View
Path = QP_Fso.BuildPath(QP_Root, "project-session-next.tsv")
QPProgress "session_wait", 1, 1
For Attempt = 1 To 1500
If QP_Fso.FileExists(Path) Then
Fields = Split(Trim(QPReadUtf8(Path)), vbTab)
If UBound(Fields) <> 1 Then Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "invalid continuation"
If Fields(0) <> QP_SessionToken Then Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "continuation token mismatch"
QP_Fso.DeleteFile Path, True
QPRequireSessionCheckpoint
QP_SessionWaiting = False
If Fields(1) = "close" Then
QPCloseBatchProject QP_SessionProject, False
QP_SessionMode = False
Exit Sub
End If
QP_ExpectedJobId = CStr(Fields(1))
QP_CurrentJobId = QP_ExpectedJobId
QP_BatchMode = True
QP_BatchState = ""
QP_BatchSaveCommitted = False
QP_NativeMutationPossible = False
If Trim(QPReadUtf8(QP_Fso.BuildPath(QP_Root, "batch.request"))) <> QP_ExpectedJobId Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "next batch authorization mismatch"
TargetPath = QPConfirmedProjectPath()
If QPCanonicalPath(TargetPath) <> QPCanonicalPath(QP_SessionProject) Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "cannot switch project inside a session"
Set View = QP_App.ActiveView
If Not View Is Nothing Then
If CStr(View.GetName(0)) <> QP_TargetSchematic Or CStr(View.Block.SheetNum) <> QP_TargetSheet Then
Set Documents = QP_App.SchematicSheetDocuments()
If Documents.Count <> 1 Then Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "owned sheet set changed"
Set Document = Documents.Item(1)
Document.Close False, ""
End If
End If
QPEnsureProject QP_App, TargetPath
Exit Sub
End If
WScript.Sleep 100
Next
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "supervisor did not release project checkpoint"
End Sub
Sub QPEvent_DocumentModified()
If QP_SessionWaiting Then QP_SessionExternalChange = True
End Sub
Sub QPEvent_BlockModified(ByVal Block)
If QP_SessionWaiting Then QP_SessionExternalChange = True
End Sub
Sub QPEvent_ProjectModified(ByVal NewProject)
If QP_SessionWaiting Then QP_SessionExternalChange = True
End Sub
Sub QPEvent_BeforeProjectModified()
If QP_SessionWaiting Then QP_SessionExternalChange = True
End Sub
Sub QPEvent_SourceFileModified(ByVal FileName)
If QP_SessionWaiting Then QP_SessionExternalChange = True
End Sub
Sub QPRequireSessionCheckpoint()
Dim Documents, View
If Not QP_OwnedProject Or Len(QP_OwnedProjectPath) = 0 Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "session project ownership was lost"
If QPCanonicalPath(QPProjectPath()) <> QPCanonicalPath(QP_OwnedProjectPath) Or _
QPCanonicalPath(QP_OwnedProjectPath) <> QPCanonicalPath(QP_SessionProject) Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "active project changed; no automatic save or close"
If QP_SessionExternalChange Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "project modified outside worker at checkpoint; no automatic save or close"
Set Documents = QP_App.SchematicSheetDocuments()
Set View = QP_App.ActiveView
If Documents.Count <> 1 Or View Is Nothing Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "owned sheet set changed at checkpoint"
If CStr(View.GetName(0)) <> QP_CheckpointSchematic Or CStr(View.Block.SheetNum) <> QP_CheckpointSheet Then _
Err.Raise vbObjectError + 873, "QuickPartReplace.ProjectSession", "active sheet changed at checkpoint"
End Sub
Sub QPInvalidatePinIndex()
Set QP_PinIndex = Nothing
QP_PinContext = ""
@@ -443,7 +572,7 @@ Sub QPEnsureProject(ByRef App, ByVal TargetPath)
CurrentPath = ""
If Not ProjectData Is Nothing Then CurrentPath = CStr(ProjectData.GetProjectFilePath())
If Len(Trim(CurrentPath)) > 0 Then
If QP_BatchMode Then Err.Raise vbObjectError + 870, "QuickPartReplace.Batch", _
If QP_BatchMode And Not (QP_SessionMode And QP_OwnedProject) Then Err.Raise vbObjectError + 870, "QuickPartReplace.Batch", _
"batch cannot take over an already open project; save your wanted edits and close the project before starting the queue"
If QPCanonicalPath(CurrentPath) <> QPCanonicalPath(TargetPath) Then _
Err.Raise vbObjectError + 853, "QuickPartReplace.Session", _
@@ -455,6 +584,7 @@ Sub QPEnsureProject(ByRef App, ByVal TargetPath)
Opened = App.OpenProject(CStr(TargetPath))
If Not Opened Then Err.Raise vbObjectError + 854, "QuickPartReplace.Session", "DxDesigner refused to open the target project"
QP_OwnedProject = True
QP_OwnedProjectPath = TargetPath
End If
Set ProjectData = App.GetProjectData()
If ProjectData Is Nothing Then _
@@ -678,7 +808,9 @@ End Sub
Sub QPCloseBatchProject(ByVal ExpectedPath, ByVal SaveChanges)
Dim Documents, Document
If Not QP_OwnedProject Or QP_RestoreTransactionOpen Then _
Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "project ownership or restoration transaction is not safe to close"
Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "project ownership or restoration transaction is not safe to close"
If QPCanonicalPath(ExpectedPath) <> QPCanonicalPath(QP_OwnedProjectPath) Or QP_SessionExternalChange Then _
Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "owned project changed; no automatic close"
If QPCanonicalPath(QPProjectPath()) <> QPCanonicalPath(ExpectedPath) Then _
Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "active project changed before save and close"
Set Documents = QP_App.SchematicSheetDocuments()
@@ -692,6 +824,7 @@ Sub QPCloseBatchProject(ByVal ExpectedPath, ByVal SaveChanges)
If Len(CStr(QP_App.GetProjectData().GetProjectFilePath())) > 0 Then _
Err.Raise vbObjectError + 871, "QuickPartReplace.Batch", "project did not close; queue stopped"
QP_OwnedProject = False
QP_OwnedProjectPath = ""
QPInvalidatePinIndex
QPInvalidateComponentIndex
End Sub
@@ -699,9 +832,9 @@ End Sub
Sub QPDiscardFailedBatchProject(ByRef ErrorDescription)
Dim ErrorNumber, ErrorSource, Description
ErrorDescription = ""
If Not QP_BatchMode Or Not QP_OwnedProject Or QP_App Is Nothing Then Exit Sub
If (Not QP_BatchMode And Not QP_SessionMode) Or Not QP_OwnedProject Or QP_App Is Nothing Then Exit Sub
On Error Resume Next
QPCloseBatchProject QPProjectPath(), False
QPCloseBatchProject QP_OwnedProjectPath, False
ErrorNumber = Err.Number
ErrorSource = Err.Source
Description = Err.Description
@@ -741,8 +874,10 @@ Sub QPFinishBatchItem()
ValueStates.Item(CStr(Index)).Add "custom_value", QPCustomValue(Command)
Next
End If
QPCloseBatchProject TargetPath, True
QP_BatchSaveCommitted = True
If FinalState = "restored_ok" Or Not QP_SessionMode Then
QPCloseBatchProject TargetPath, True
QP_BatchSaveCommitted = True
End If
If FinalState = "restored_ok" Then
QPProgress "verify_saved_project", 0, 1
QPEnsureProject QP_App, TargetPath
@@ -757,12 +892,27 @@ Sub QPFinishBatchItem()
Plans.Add CStr(Index), Candidate
Next
QPVerifyRestoredPlans Command, Records, Plans, ValueStates
QPCloseBatchProject TargetPath, True
If Not QP_SessionMode Then QPCloseBatchProject TargetPath, True
FinalState = "saved_ok"
QP_BatchMessage = QP_BatchMessage & " Saved, reopened for readback, and closed."
If QP_SessionMode Then
QP_BatchMessage = QP_BatchMessage & " Saved and reopened for readback; owned project checkpoint verified."
Else
QP_BatchMessage = QP_BatchMessage & " Saved, reopened for readback, and closed."
End If
End If
QP_BatchMode = False
QPWriteStatus QP_Root, QP_CurrentJobId, FinalState, "batch_closed", QP_BatchMessage
If QP_SessionMode Then
QP_NativeMutationPossible = False
QP_SessionExternalChange = False
QP_CheckpointSchematic = QP_TargetSchematic
QP_CheckpointSheet = QP_TargetSheet
QP_SessionWaiting = True
QPWriteStatus QP_Root, QP_CurrentJobId, FinalState, "session_verified", QP_BatchMessage
QPWriteUtf8 QP_Fso.BuildPath(QP_Root, "project-session-result.tsv"), _
QP_SessionToken & vbTab & QP_CurrentJobId & vbTab & FinalState & vbTab & "session_verified"
Else
QPWriteStatus QP_Root, QP_CurrentJobId, FinalState, "batch_closed", QP_BatchMessage
End If
QPProgress "finished", 1, 1
End Sub
@@ -45,6 +45,7 @@ def execute_batch(
expected_item,
stop_event: Event,
continue_after_backup_failure: bool = False,
reuse_project_session: bool = True,
) -> BatchRunResult:
preparer = service._quick_run_preparer
retention = maintain_quick_run_storage(preparer.data_root)
@@ -112,7 +113,7 @@ def execute_batch(
)
else:
progress = session.progress
with backups:
with backups, preparer.project_session_scope(enabled=reuse_project_session) as project_session:
while not progress.queue_complete:
if stop_event.is_set():
backups.commit_prefetched(progress)
@@ -123,6 +124,7 @@ def execute_batch(
if current is None:
raise TaskCenterError('quick_run_queue_progress', '队列未结束但找不到下一项,已停止。')
current_key = _path_key(current)
project_session.prepare(current)
backups.prepare(current, progress)
service._batch_feedback = (task_id, progress, f'正在处理 {current.name}')
if stop_event.is_set():
@@ -139,7 +141,8 @@ def execute_batch(
new_part_number=expected[2], job_id=session.commands[session.next_index][1]) as metric:
try:
last_result = preparer.execute_step(task_id, projects, rules, copy_part_number_to_value=task.copy_part_number_to_value,
expected_item=expected, batch_mode=True, batch_session=session)
expected_item=expected, batch_mode=True, batch_session=session,
**({'project_session': project_session} if project_session.enabled else {}))
metric['state'] = last_result.state
metric['completed_units'] = int(last_result.state in {'saved_ok', 'restored_ok', 'no_match'})
finally:
@@ -0,0 +1,139 @@
"""A supervised worker retained between verified steps of one owned project."""
from __future__ import annotations
from pathlib import Path
import subprocess
from threading import Event, Thread
from uuid import uuid4
from .worker_monitor import WorkerMonitorError, run_monitored_process
def _write_control(path: Path, value: str):
temporary = path.with_name(path.name + '.' + uuid4().hex + '.tmp')
temporary.write_text(value, encoding='utf-8')
temporary.replace(path)
class ProjectSessionWorker:
"""Only a saved-and-reopened checkpoint releases the caller for its next step.
The VBS worker owns CAD. This driver never attaches to COM or terminates CAD.
A separate monitor thread retains the existing idle watchdog and worker job.
"""
def __init__(self, project: Path, root: Path):
self.project, self.root = Path(project), Path(root)
self.token = uuid4().hex
self._done, self._abort = Event(), Event()
self._thread = None
self._command = None
self._result = self._error = None
self._waiting = False
self._closed = False
self._failure_delivered = False
self._timeout = 150
self.starts = 0
def _monitor(self, command, timeout):
try:
self._result = run_monitored_process(command, timeout, abort_event=self._abort)
except Exception as error:
self._error = error
finally:
self._done.set()
def run_step(self, command: tuple[str, ...], timeout: float):
if self._closed:
raise WorkerMonitorError('project session is already closed')
if Path(command[3]).resolve() != self.root.resolve():
raise WorkerMonitorError('project session evidence root changed')
if self._command is not None and command[:-1] != self._command[:-1]:
raise WorkerMonitorError('project session worker configuration changed')
job = command[-1]
if self._thread is None:
self.root.mkdir(parents=True, exist_ok=True)
_write_control(self.root / 'project-session.request', f'{self.token}\t{self.project}\t{job}')
(self.root / 'project-session-next.tsv').unlink(missing_ok=True)
(self.root / 'project-session-result.tsv').unlink(missing_ok=True)
self._command, self._timeout = command, timeout
self._thread = Thread(target=self._monitor, args=(command, timeout), daemon=True,
name='dxpart-project-session')
self.starts += 1
self._thread.start()
else:
if not self._waiting:
raise WorkerMonitorError('project session has no verified checkpoint')
self._waiting = False
_write_control(self.root / 'project-session-next.tsv', f'{self.token}\t{job}')
while True:
if self._done.is_set():
if self._error is not None:
raise self._error
if self._result.returncode == 0:
raise WorkerMonitorError('project session exited before authorized closing')
self._failure_delivered = True
return self._result
try:
fields = (self.root / 'project-session-result.tsv').read_text(encoding='utf-8-sig').strip().split('\t')
except (FileNotFoundError, PermissionError):
fields = ()
if len(fields) == 4 and fields[:2] == [self.token, job]:
if fields[2] not in {'saved_ok', 'no_match'} or fields[3] != 'session_verified':
raise WorkerMonitorError('project session returned an invalid checkpoint')
self._waiting = True
return subprocess.CompletedProcess(command, 0, '', '')
self._done.wait(0.025)
def close(self):
if self._closed:
return
self._closed = True
try:
if self._thread is None:
return
if not self._done.is_set():
_write_control(self.root / 'project-session-next.tsv', f'{self.token}\tclose')
if not self._done.wait(min(30, max(10, self._timeout))):
self._abort.set()
self._done.wait(10)
raise WorkerMonitorError('owned project did not acknowledge session closing')
if self._error is not None:
raise self._error
if self._result.returncode != 0 and not self._failure_delivered:
raise WorkerMonitorError('owned project session did not close cleanly: ' + self._result.stderr)
finally:
if self._done.is_set():
for name in ('project-session.request', 'project-session-next.tsv', 'project-session-result.tsv'):
(self.root / name).unlink(missing_ok=True)
class ProjectSessionScope:
"""One serial task can visit projects, but can hold only one worker at a time."""
def __init__(self, fallback, *, enabled):
self.fallback, self.enabled = fallback, enabled
self.worker = None
def __enter__(self):
return self
def run_step(self, project, command, timeout):
if not self.enabled:
return self.fallback(command, timeout)
self.prepare(project)
if self.worker is None:
self.worker = ProjectSessionWorker(Path(project), Path(command[3]))
return self.worker.run_step(command, timeout)
def prepare(self, project):
if self.worker is not None and (self.worker.project.resolve() != Path(project).resolve()
or self.worker._done.is_set()):
self.worker.close()
self.worker = None
def __exit__(self, error_type, error, traceback):
if self.worker is not None:
try:
self.worker.close()
except Exception:
self.worker._abort.set()
raise
@@ -3,6 +3,7 @@
from __future__ import annotations
from collections.abc import Callable
from contextlib import contextmanager
from dataclasses import dataclass
from datetime import datetime, timezone
from functools import lru_cache
@@ -292,6 +293,20 @@ class QuickRunPreparer:
_vbs_worker_paths(handoff.script_path, handoff.script_path.parent),
)
@contextmanager
def project_session_scope(self, *, enabled=True):
"""Retain only the built-in supervised worker; injected workers stay compatible."""
from .project_session import ProjectSessionScope
from .worker_monitor import WorkerMonitorError
try:
with ProjectSessionScope(self._process_runner,
enabled=enabled and self._process_runner is _run_process) as scope:
yield scope
except (WorkerMonitorError, subprocess.TimeoutExpired) as error:
_write_uncertain_flag(self._data_root / 'quick-run/uncertain.flag', 'project_session_cleanup')
raise TaskCenterError('quick_run_uncertain',
'工程会话未能确认安全关闭,队列已停止;请保留工程和执行证据后核验恢复。') from error
def execute_step(
self,
task_id: str,
@@ -302,6 +317,7 @@ class QuickRunPreparer:
expected_item: tuple[str, str, str, str] | None = None,
batch_mode: bool = False,
batch_session: QuickRunBatchSession | None = None,
project_session=None,
) -> QuickRunStepResult:
"""Prepare or resume a queue, then execute one replacement rule end to end."""
uncertain_path = self._data_root / "quick-run" / "uncertain.flag"
@@ -378,7 +394,10 @@ class QuickRunPreparer:
self.invalidate_discovery(Path(selected_command[2]))
try:
completed = self._process_runner(command, IDLE_PROGRESS_TIMEOUT_SECONDS)
if project_session is not None:
completed = project_session.run_step(Path(selected_command[2]), command, IDLE_PROGRESS_TIMEOUT_SECONDS)
else:
completed = self._process_runner(command, IDLE_PROGRESS_TIMEOUT_SECONDS)
except subprocess.TimeoutExpired as error:
_write_uncertain_flag(uncertain_path, "worker_timeout")
_append_log(handoff.log_path, "quick_run_uncertain worker_timeout")
@@ -439,7 +458,9 @@ class QuickRunPreparer:
_append_log(handoff.log_path, f"quick_run_uncertain uncorrelated_status exit_code={completed.returncode}")
raise TaskCenterError("quick_run_uncertain", "quick-run worker returned an uncorrelated status; reconcile the project before retrying")
_, state, code, message = changed
if batch_mode and completed.returncode == 0 and state in DONE_STATES and code != "batch_closed":
verified_session = bool(project_session is not None and project_session.enabled
and code == 'session_verified')
if batch_mode and completed.returncode == 0 and state in DONE_STATES and code != "batch_closed" and not verified_session:
_write_uncertain_flag(uncertain_path, "batch_save_close_unverified")
raise TaskCenterError("quick_run_uncertain", "批量步骤未确认保存关闭完成,队列已停止,不会继续下一工程。")
check_log_rotation = (
@@ -669,63 +690,16 @@ class QuickRunPreparer:
collect_components: bool = False,
) -> _ProjectDiscovery:
"""Enumerate sheets and requested source parts while the owned project is open."""
project = project_path.resolve(strict=True)
token = uuid4().hex
job_id = _safe_run_token("discover_" + token)
root = self._data_root / "quick-run-history" / ("sheet-discovery-" + token)
root.mkdir(parents=True, exist_ok=False)
script = root / "QuickPartReplace.vbs"
shutil.copyfile(self._required_script_source(), script)
(root / "command.tsv").write_text(
"task_id\tjob_id\tproject_path\told_part\tnew_part\tvalue_mode\r\n"
f"sheet_discovery\t{job_id}\t{project}\tDISCOVERY_OLD\tDISCOVERY_NEW\tpreserve\r\n",
encoding="utf-8",
newline="",
)
(root / "status.tsv").write_text("job_id\tstate\tcode\tmessage\r\n", encoding="utf-8", newline="")
(root / "batch.request").write_text(job_id, encoding="ascii")
(root / "sheet-discovery.request").write_text(job_id, encoding="ascii")
requested: dict[str, str] = {}
for old_part_number in old_part_numbers:
requested.setdefault(old_part_number.casefold(), old_part_number)
(root / "inventory-request.tsv").write_text(
"old_part\r\n" + "".join(
f"{_encode_vbs_field(old_part_number)}\r\n"
for old_part_number in requested.values()
),
encoding="utf-8",
newline="",
)
if collect_components:
(root / "component-inventory.request").write_text(job_id, encoding="ascii")
script_argument, root_argument = _vbs_worker_paths(script, root)
command = (
str(self._cscript_resolver()),
"//nologo",
script_argument,
root_argument,
*_native_helper_launch_arguments(),
job_id,
)
try:
completed = self._process_runner(command, IDLE_PROGRESS_TIMEOUT_SECONDS)
except (OSError, subprocess.SubprocessError) as error:
raise TaskCenterError(
"quick_run_sheet_discovery",
f"枚举工程图页时执行器未能安全结束:{project};{error}",
) from error
(root / "worker-output.txt").write_text(completed.stdout + "\n" + completed.stderr, encoding="utf-8")
if completed.returncode != 0:
detail = completed.stderr.strip() or completed.stdout.strip() or "sheet discovery failed"
raise TaskCenterError("quick_run_sheet_discovery", _session_failure_message(detail))
sheets = _read_discovered_sheets(root / "sheets.tsv", project)
matches = _read_discovery_inventory(root / "inventory.tsv", project, sheets)
if collect_components:
from .inventory import read_component_inventory
components = read_component_inventory(root / "components.tsv", project, sheets)
else:
components = ()
return _ProjectDiscovery(sheets, matches, components)
from .project_discovery import DiscoveryRuntime, discover_project
return discover_project(project_path, old_part_numbers,
data_root=self._data_root, script_source=self._required_script_source(),
collect_components=collect_components,
runtime=DiscoveryRuntime(
self._process_runner, self._cscript_resolver, _vbs_worker_paths,
_native_helper_launch_arguments, _session_failure_message,
_read_discovered_sheets, _read_discovery_inventory,
IDLE_PROGRESS_TIMEOUT_SECONDS))
@property
def vbs_root_compatible(self) -> bool:
@@ -24,6 +24,7 @@ class ProgressWatch:
raise ValueError('Idle timeout must be positive')
self.token = token
self.job_id = job_id
self.current_job_id = job_id
self.idle_timeout = idle_timeout
self.last_progress = started
self.sequence = 0
@@ -39,7 +40,10 @@ class ProgressWatch:
def accept(self, line: bytes, now: float) -> bool:
try:
fields = line.decode('ascii').strip().split('\t')
if len(fields) != 8 or fields[:3] != ['DX_PROGRESS', self.token, self.job_id]:
if len(fields) not in {8, 9} or fields[:3] != ['DX_PROGRESS', self.token, self.job_id]:
return False
current_job = fields[8] if len(fields) == 9 else self.job_id
if not re.fullmatch(r'[A-Za-z0-9_.-]{1,128}', current_job):
return False
sequence, done, total, safe = (int(fields[index]) for index in (3, 5, 6, 7))
if not self.sequence < sequence <= 2**31 - 1 or not re.fullmatch('[a-z_]{1,64}', fields[4]):
@@ -48,6 +52,11 @@ class ProgressWatch:
return False
except (ValueError, UnicodeError):
return False
if current_job != self.current_job_id:
self.current_job_id = current_job
self.stage_seconds = {}
self.started = self.stage_started = now
self.stage = fields[4]
if fields[4] != self.stage:
self.stage_seconds[self.stage] = self.stage_seconds.get(self.stage, 0.0) + max(0.0, now - self.stage_started)
self.stage_started = now
@@ -69,7 +78,8 @@ class ProgressWatch:
now = time.monotonic() if now is None else now
stages = dict(self.stage_seconds)
stages[self.stage] = stages.get(self.stage, 0.0) + max(0.0, now - self.stage_started)
return {name: getattr(self, name) for name in ('token', 'job_id', 'sequence', 'stage', 'done', 'total', 'safe_stop', 'stop_requested')} | {
return {name: getattr(self, name) for name in ('token', 'sequence', 'stage', 'done', 'total', 'safe_stop', 'stop_requested')} | {
'job_id': self.current_job_id,
'elapsed_seconds': max(0.0, now - self.started), 'stage_seconds': stages}
@@ -147,7 +157,7 @@ class _OwnedWorkers:
self.job.Close()
def run_monitored_process(command: tuple[str, ...], idle_timeout: float) -> subprocess.CompletedProcess[str]:
def run_monitored_process(command: tuple[str, ...], idle_timeout: float, *, abort_event=None) -> subprocess.CompletedProcess[str]:
root = Path(command[3])
job_id = command[-1]
token = uuid4().hex
@@ -195,6 +205,8 @@ def run_monitored_process(command: tuple[str, ...], idle_timeout: float) -> subp
_publish_progress(progress_path, watch.snapshot())
_atomic_text(ready, token)
while process.poll() is None:
if abort_event is not None and abort_event.is_set():
raise WorkerMonitorError('project session supervisor requested worker cleanup')
try:
receive(*messages.get(timeout=min(0.1, idle_timeout / 10)))
for pending in range(128):
+114
View File
@@ -0,0 +1,114 @@
import json
from pathlib import Path
import sys
import subprocess
import pytest
from dx_productivity.trial_task_center.project_session import ProjectSessionWorker, ProjectSessionScope
from dx_productivity.trial_task_center.worker_monitor import ProgressWatch, WorkerMonitorError
def toy_worker(root):
script = root / 'toy_session.py'
script.write_text('''import pathlib,sys,time,json,os
root=pathlib.Path(sys.argv[1]); initial=sys.argv[4]; monitor=sys.argv[5]
while not (root/f'monitor-{monitor}.ready').exists():time.sleep(.005)
session=(root/'project-session.request').read_text(encoding='utf-8').split('\\t')[0]
job=initial; sequence=0
with (root/'starts.txt').open('a') as f:f.write(str(os.getpid())+'\\n')
while True:
sequence+=1
print(f'DX_PROGRESS\\t{monitor}\\t{initial}\\t{sequence}\\tsession_wait\\t1\\t1\\t1\\t{job}',flush=True)
(root/'project-session-result.tsv').write_text(f'{session}\\t{job}\\tsaved_ok\\tsession_verified',encoding='utf-8')
with (root/'steps.txt').open('a') as f:f.write(job+'\\n')
while not (root/'project-session-next.tsv').exists():time.sleep(.005)
token,job=(root/'project-session-next.tsv').read_text().split('\\t')
(root/'project-session-next.tsv').unlink()
if token!=session:sys.exit(8)
if job=='close':break
(root/'closed.txt').write_text('closed')
''', encoding='utf-8')
return (sys.executable, '-u', str(script), str(root), sys.executable, '', 'job1')
def test_same_project_steps_retain_one_supervised_worker_and_close(tmp_path):
command = toy_worker(tmp_path)
session = ProjectSessionWorker(tmp_path / '工程.prj', tmp_path)
try:
assert session.run_step(command, 3).returncode == 0
assert session.run_step((*command[:-1], 'job2'), 3).returncode == 0
finally:
session.close()
assert (tmp_path / 'closed.txt').exists()
assert (tmp_path / 'steps.txt').read_text().splitlines() == ['job1', 'job2']
assert len((tmp_path / 'starts.txt').read_text().splitlines()) == 1
assert not (tmp_path / 'project-session.request').exists()
def test_session_progress_keeps_monitor_identity_and_resets_each_step():
watch = ProgressWatch('token', 'first', 10, 0)
first = b'DX_PROGRESS\ttoken\tfirst\t1\topen_project\t0\t1\t1\tfirst\n'
second = b'DX_PROGRESS\ttoken\tfirst\t2\tnative_replace\t0\t1\t0\tsecond\n'
assert watch.accept(first, 1)
assert watch.accept(second, 5)
value = watch.snapshot(now=6)
assert value['job_id'] == 'second'
assert value['stage_seconds'] == {'native_replace': 1}
assert value['elapsed_seconds'] == 1
assert not watch.accept(second.replace(b'\tfirst\t2', b'\tforeign\t3'), 6)
def test_real_vbs_session_authorization_fails_before_cad_for_missing_project(tmp_path):
script = Path(__file__).resolve().parents[2] / 'integration/dxdesigner795/QuickPartReplace.vbs'
project = tmp_path / 'missing.prj'
(tmp_path / 'command.tsv').write_text(f'job_id\tproject_path\njob\t{project}\n')
(tmp_path / 'batch.request').write_text('job')
(tmp_path / 'project-session.request').write_text(f'{"a"*32}\t{project}\tjob')
result = subprocess.run((r'C:\Windows\SysWOW64\cscript.exe', '//nologo', str(script),
str(tmp_path), sys.executable, '', 'job'),
capture_output=True, timeout=10, text=True)
assert result.returncode == 2
assert 'confirmed project file does not exist' in result.stderr
def test_switching_project_closes_previous_worker_before_starting_next(tmp_path):
roots = [tmp_path / 'first', tmp_path / 'second']
for root in roots:
root.mkdir()
with ProjectSessionScope(None, enabled=True) as scope:
assert scope.run_step(roots[0] / 'a.prj', toy_worker(roots[0]), 3).returncode == 0
scope.prepare(roots[1] / 'b.prj')
assert (roots[0] / 'closed.txt').exists()
assert scope.run_step(roots[1] / 'b.prj', toy_worker(roots[1]), 3).returncode == 0
assert (roots[1] / 'closed.txt').exists()
def test_wrong_session_checkpoint_cannot_release_next_step(tmp_path):
command = toy_worker(tmp_path)
script = Path(command[2])
script.write_text(script.read_text(encoding='utf-8').replace(
"f'{session}\\t{job}\\tsaved_ok\\tsession_verified'",
"f'wrong-token\\t{job}\\tsaved_ok\\tsession_verified'").replace(
"while not (root/'project-session-next.tsv').exists():time.sleep(.005)",
'sys.exit(0)'), encoding='utf-8')
session = ProjectSessionWorker(tmp_path / 'a.prj', tmp_path)
try:
with pytest.raises(WorkerMonitorError, match='before authorized closing'):
session.run_step(command, 3)
finally:
session.close()
def test_completed_failure_is_delivered_and_next_step_starts_fresh_worker(tmp_path):
command = toy_worker(tmp_path)
script = Path(command[2])
script.write_text(script.read_text(encoding='utf-8').replace(
'job=initial; sequence=0', "job=initial; sequence=0\nif job=='failed':sys.exit(7)"), encoding='utf-8')
project = tmp_path / 'a.prj'
with ProjectSessionScope(None, enabled=True) as scope:
failed = scope.run_step(project, (*command[:-1], 'failed'), 3)
assert failed.returncode == 7
previous = scope.worker
assert scope.run_step(project, command, 3).returncode == 0
assert scope.worker is not previous
assert (tmp_path / 'closed.txt').exists()
+112
View File
@@ -0,0 +1,112 @@
"""Run native replacements on a prepared disposable project, then independently read back.
The inventory must come from native discovery of the same source project. This
runner refuses a project outside --output; prepare copies before invoking it.
"""
import argparse
from dataclasses import asdict
import json
import inspect
import os
from pathlib import Path
import sys
from threading import Event
import time
import traceback
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--output', type=Path, required=True)
parser.add_argument('--project', type=Path, required=True)
parser.add_argument('--inventory', type=Path, required=True)
parser.add_argument('--source-root', type=Path, default=Path(__file__).resolve().parents[1])
parser.add_argument('--mode', choices=('baseline', 'reuse'), required=True)
parser.add_argument('--old', default='4100-CA0000-T7')
parser.add_argument('--new', default='4100-CA0000-T0')
parser.add_argument('--refs', default='R32A8,R39A8,RG47')
args = parser.parse_args()
output, project = args.output.resolve(), args.project.resolve()
if not project.is_relative_to(output) or not project.is_file():
parser.error('project must be a disposable copy inside output')
sys.path.insert(0, str(args.source_root.resolve() / 'src'))
os.environ['PYTHONPATH'] = str(args.source_root.resolve() / 'src') + os.pathsep + os.environ.get('PYTHONPATH', '')
from dx_productivity.trial_task_center.logging_setup import configure_logging
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.target_plan import ComponentTarget, TargetPlanRow
source = json.loads(args.inventory.read_text(encoding='utf-8'))
sheets = tuple(tuple(sheet) for sheet in source['sheets'])
inventory = tuple(ComponentTarget(project, row['schematic_name'], row['sheet_number'],
row['uid'], row['refdes'], row['old_part_number'], row['old_value']) for row in source['components'])
ref_list = args.refs.split(',')
selected = set(ref_list)
assert selected <= {row.refdes for row in inventory}
output.mkdir(parents=True, exist_ok=True)
report = {'mode': args.mode, 'project': str(project), 'source_root': str(args.source_root),
'selected': sorted(selected), 'sheets': len(sheets)}
store = TaskStore(output / 'tasks.db')
preparer = QuickRunPreparer(output / 'data', sheet_discoverer=lambda _: sheets)
service = TaskCenterService(store, configure_logging(output / 'data'), quick_run_preparer=preparer)
try:
import win32com.client
try:
app = win32com.client.GetActiveObject('Viewdraw.Application')
except Exception:
app = None
if app is not None and app.GetProjectData().GetProjectFilePath():
raise RuntimeError('save and close existing CAD project before native measurement')
task = service.create_project_tasks(project.parent)[0]
service.add_rule(task.task_id, args.old, args.new)
store.record_target_inventory(task.task_id, inventory)
rows = tuple(TargetPlanRow(target, target.refdes in selected, args.new,
sync_nc=target.refdes != ref_list[1]) for target in inventory)
service.replace_target_plan(task.task_id, rows)
report['task_id'] = task.task_id
progress = service.quick_run_progress(task.task_id)
expected = (str(progress.next_project_path), progress.next_old_part_number,
progress.next_new_part_number, 'preserve')
print('native_start', args.mode, task.task_id, flush=True)
started = time.perf_counter()
session_option = ({'reuse_project_session': args.mode == 'reuse'}
if 'reuse_project_session' in inspect.signature(service.execute_quick_run_queue).parameters else {})
if args.mode == 'reuse' and not session_option:
raise RuntimeError('selected source does not implement project session reuse')
result = service.execute_quick_run_queue(task.task_id, expected_item=expected, stop_event=Event(),
**session_option)
report['queue_seconds'] = time.perf_counter() - started
report['result'] = asdict(result)
print('native_result', args.mode, report['queue_seconds'], result.progress, flush=True)
assert result.progress.queue_complete and result.progress.failed_items == 0
evidence = output / 'data' / 'tasks' / task.task_id / 'quick-run'
text = (evidence / 'quick-part-replace.log').read_text(encoding='utf-8')
report['worker_starts'] = len(tuple(evidence.glob('monitor-*.ready')))
report['open_project_calls'] = text.count('stage=open_project target=')
events = [json.loads(line) for line in service.tail_log(task.task_id, limit=None)]
report['timings'] = [event for event in events if event['operation'] in {'execution_timing', 'quick_run_executed'}]
reader = QuickRunPreparer(output / 'independent-read')
started = time.perf_counter()
actual = reader._discover_project_sheets(project, (args.old, args.new), collect_components=True)
report['readback_seconds'] = time.perf_counter() - started
by_key = {(row.schematic_name, row.sheet_number, row.uid): row for row in actual.components}
comparisons = []
for target in inventory:
row = by_key[(target.schematic_name, target.sheet_number, target.uid)]
expected_part = args.new if target.refdes in selected else target.old_part_number
comparisons.append({'refdes': target.refdes, 'sheet': target.sheet_number,
'expected': expected_part, 'actual': row.old_part_number})
assert row.refdes == target.refdes and row.old_part_number == expected_part
report['comparisons'] = comparisons
report['verified'] = True
except Exception as error:
report['error'] = str(error)
traceback.print_exc()
finally:
(output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2, default=str), encoding='utf-8')
store.close()
return 0 if report.get('verified') else 1
if __name__ == '__main__':
raise SystemExit(main())
+97
View File
@@ -0,0 +1,97 @@
"""Exercise clean closing and external-edit/foreign-project guards on copies only."""
import argparse
import json
import os
from pathlib import Path
import shutil
import sys
import time
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.logging_setup import configure_logging
def run(source, output, sheets, mode):
import win32com.client
app = win32com.client.GetActiveObject('Viewdraw.Application')
assert not app.GetProjectData().GetProjectFilePath()
project_root = output / 'project'
shutil.copytree(source.parent, project_root)
project = project_root / source.name
store = TaskStore(output / 'tasks.db')
preparer = QuickRunPreparer(output / 'data', sheet_discoverer=lambda _: sheets)
service = TaskCenterService(store, configure_logging(output / 'data'), quick_run_preparer=preparer)
task = service.create_project_tasks(project_root)[0]
service.add_rule(task.task_id, 'SESSION_PROBE_ABSENT_PART', 'SESSION_PROBE_NEW_PART')
child = service.for_project_task(task.task_id)
preparer = child._quick_run_preparer
projects, rules = child.projects(task.task_id), child.rules(task.task_id)
session = preparer.begin_batch_session(task.task_id, projects, rules)
record = {'mode': mode, 'project': str(project)}
foreign = None
try:
try:
with preparer.project_session_scope() as retained:
progress = session.progress
result = preparer.execute_step(task.task_id, projects, rules, batch_mode=True,
batch_session=session, project_session=retained,
expected_item=(str(project), progress.next_old_part_number, progress.next_new_part_number, 'preserve'))
assert result.state == 'no_match'
if mode == 'edit':
for component in app.ActiveView.Query(128, 0):
attribute = component.FindAttribute('Value')
if attribute is not None:
record['previous_value'] = attribute.Value
attribute.Value = 'SESSION_EXTERNAL_EDIT_PROBE'
record['external_edit_written'] = True
break
assert record.get('external_edit_written')
time.sleep(0.2)
elif mode == 'foreign':
app.SchematicSheetDocuments().Item(1).Close(False, '')
app.CloseProject()
foreign_root = output / 'foreign'
shutil.copytree(source.parent, foreign_root)
foreign = foreign_root / source.name
assert app.OpenProject(str(foreign))
record['closed_cleanly'] = True
except Exception as error:
record['error'] = str(error)
record['error_code'] = getattr(error, 'code', '')
active = app.GetProjectData().GetProjectFilePath()
record['active_after_guard'] = active
if mode == 'clean':
assert record.get('closed_cleanly') and not active
else:
assert record.get('error_code') == 'quick_run_uncertain'
assert Path(active).resolve() == (foreign or project).resolve()
record['preserved_external_state'] = True
record['passed'] = True
finally:
active = app.GetProjectData().GetProjectFilePath()
if active and Path(active).resolve() in {project.resolve(), (foreign or project).resolve()}:
# Explicit cleanup of this probe's own disposable edits/projects.
documents = app.SchematicSheetDocuments()
while documents.Count:
documents.Item(1).Close(False, '')
app.CloseProject()
store.close()
(output / 'guard-report.json').write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8')
print(json.dumps(record, ensure_ascii=False), flush=True)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--source-copy', type=Path, required=True)
parser.add_argument('--inventory', type=Path, required=True)
parser.add_argument('--output', type=Path, required=True)
args = parser.parse_args()
args.output = args.output.resolve()
args.output.mkdir(parents=True, exist_ok=False)
os.environ['PYTHONPATH'] = str(Path(__file__).resolve().parents[1] / 'src')
sheets = tuple(tuple(row) for row in json.loads(args.inventory.read_text(encoding='utf-8'))['sheets'])
for mode in ('clean', 'edit', 'foreign'):
run(args.source_copy.resolve(), args.output / mode, sheets, mode)
+73
View File
@@ -0,0 +1,73 @@
"""Probe real sheet transitions and between-step closing on a disposable copy."""
import argparse
import json
import os
from pathlib import Path
import shutil
import sys
import time
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'src'))
from dx_productivity.trial_task_center.quick_run import QuickRunPreparer
from dx_productivity.trial_task_center.service import TaskCenterService
from dx_productivity.trial_task_center.store import TaskStore
from dx_productivity.trial_task_center.logging_setup import configure_logging
def main():
import win32com.client
parser = argparse.ArgumentParser()
parser.add_argument('--source-copy', type=Path, required=True)
parser.add_argument('--inventory', type=Path, required=True)
parser.add_argument('--output', type=Path, required=True)
args = parser.parse_args()
app = win32com.client.GetActiveObject('Viewdraw.Application')
assert not app.GetProjectData().GetProjectFilePath(), 'a project is already open'
output = args.output.resolve()
output.mkdir(parents=True, exist_ok=False)
source = args.source_copy.resolve()
project = output / 'project' / source.name
shutil.copytree(source.parent, project.parent)
sheets = tuple(tuple(row) for row in json.loads(args.inventory.read_text(encoding='utf-8'))['sheets'])
assert len(sheets) >= 4
store = TaskStore(output / 'tasks.db')
preparer = QuickRunPreparer(output / 'data', sheet_discoverer=lambda _: sheets)
service = TaskCenterService(store, configure_logging(output / 'data'), quick_run_preparer=preparer)
report = {'project': str(project), 'steps': []}
started = time.perf_counter()
try:
task = service.create_project_tasks(project.parent)[0]
service.add_rule(task.task_id, 'SESSION_PROBE_ABSENT_PART', 'SESSION_PROBE_NEW_PART')
child = service.for_project_task(task.task_id)
preparer = child._quick_run_preparer
projects, rules = child.projects(task.task_id), child.rules(task.task_id)
session = preparer.begin_batch_session(task.task_id, projects, rules)
with preparer.project_session_scope() as retained:
for _ in range(3):
progress = session.progress
step_started = time.perf_counter()
result = preparer.execute_step(task.task_id, projects, rules, batch_mode=True,
batch_session=session, project_session=retained,
expected_item=(str(project), progress.next_old_part_number,
progress.next_new_part_number, 'preserve'))
view = app.ActiveView
actual = (view.GetName(0), view.Block.SheetNum)
assert result.state == 'no_match'
assert actual == (progress.next_schematic_name, progress.next_sheet_number)
report['steps'].append({'sheet': actual, 'state': result.state,
'seconds': time.perf_counter() - step_started})
assert retained.worker.starts == 1
assert session.progress.completed_items == 3 and not session.progress.queue_complete
assert not app.GetProjectData().GetProjectFilePath()
report.update(passed=True, closed_between_steps=True, worker_starts=1,
completed_items=3, total_items=session.progress.total_items)
finally:
report['seconds'] = time.perf_counter() - started
(output / 'report.json').write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
store.close()
print(json.dumps(report, ensure_ascii=False), flush=True)
if __name__ == '__main__':
os.environ['PYTHONPATH'] = str(Path(__file__).resolve().parents[1] / 'src')
main()