外卖跑腿系统采购验收：范围变更后如何阻止旧版本通过

from dataclasses import dataclass, field

@dataclass
class Project:
    owner: str
    revision: int = 1
    scope: frozenset = frozenset({'takeout'})
    evidence: dict = field(default_factory=dict)
    accepted: bool = False

    def validate(self):
        if not isinstance(self.owner, str) or not self.owner:
            raise ValueError('invalid_owner')
        if type(self.revision) is not int or self.revision < 1:
            raise ValueError('invalid_revision')
        if not isinstance(self.scope, frozenset) or not self.scope or not all(
                isinstance(x, str) and x for x in self.scope):
            raise ValueError('invalid_scope')
        if not isinstance(self.evidence, dict) or any(
                k not in self.scope or v not in {'pass','fail','unknown'}
                for k, v in self.evidence.items()):
            raise ValueError('invalid_evidence')
        if type(self.accepted) is not bool or (self.accepted and any(
                self.evidence.get(k) != 'pass' for k in self.scope)):
            raise ValueError('invalid_acceptance')

    def change(self, actor, expected, scope):
        self.validate()
        if type(expected) is not int or expected < 1:
            return 'invalid_expected'
        if actor != self.owner:
            return 'forbidden'
        if expected != self.revision:
            return 'conflict'
        if not scope or not all(isinstance(x, str) and x for x in scope):
            return 'invalid_scope'
        self.scope = frozenset(scope)
        self.revision += 1
        self.evidence = {}
        self.accepted = False
        return 'changed'

    def record(self, actor, expected, item, result):
        self.validate()
        if type(expected) is not int or expected < 1:
            return 'invalid_expected'
        if actor != self.owner:
            return 'forbidden'
        if expected != self.revision:
            return 'conflict'
        if item not in self.scope or result not in {'pass', 'fail', 'unknown'}:
            return 'invalid_result'
        self.evidence[item] = result
        self.accepted = False
        return 'recorded'

    def accept(self, actor, expected):
        self.validate()
        if type(expected) is not int or expected < 1:
            return 'invalid_expected'
        if actor != self.owner:
            return 'forbidden'
        if expected != self.revision:
            return 'conflict'
        if any(self.evidence.get(k) != 'pass' for k in self.scope):
            return 'incomplete'
        self.accepted = True
        return 'accepted'

if __name__ == '__main__':
    p = Project('buyer-A')
    assert p.accept('buyer-A', 1) == 'incomplete'
    assert p.record('buyer-A', 1, 'takeout', 'pass') == 'recorded'
    assert p.accept('buyer-A', 1) == 'accepted'
    assert p.change('other', 1, {'takeout', 'errands'}) == 'forbidden'
    assert p.revision == 1 and p.accepted
    assert p.change('buyer-A', 1, {'takeout', 'errands'}) == 'changed'
    assert not p.accepted and p.evidence == {}
    assert p.accept('buyer-A', 1) == 'conflict'
    assert p.record('buyer-A', 2, 'takeout', 'pass') == 'recorded'
    assert p.record('buyer-A', 2, 'errands', 'unknown') == 'recorded'
    assert p.accept('buyer-A', 2) == 'incomplete'
    assert p.record('buyer-A', 2, 'errands', 'pass') == 'recorded'
    assert p.accept('buyer-A', 2) == 'accepted'
    import copy
    for patch in [dict(owner=''), dict(revision=True),
                  dict(evidence={'takeout':'pass'}),
                  dict(evidence={'other':'pass'})]:
        damaged = copy.deepcopy(p)
        for key,value in patch.items():
            setattr(damaged,key,value)
        before = copy.deepcopy(damaged)
        try:
            damaged.accept('buyer-A',2)
        except ValueError:
            pass
        else:
            raise AssertionError('damaged object accepted')
        assert damaged == before
    assert p.accept('buyer-A', True) == 'invalid_expected'
    print('18 assertions passed; damaged objects unchanged; accepted=True')