읽은 코드의 범위를 버전에 묶어 남기는 검토 모듈

"""Compare declared source metadata and reviewed line ranges; no file access."""
import re

class ReviewError(ValueError):
    pass

def _keys(value, fields):
    if not isinstance(value, dict) or set(value) != set(fields):
        raise ReviewError('INVALID_FIELDS')

def _text(value):
    if not isinstance(value, str) or not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9._-]{0,79}', value):
        raise ReviewError('INVALID_LABEL')
    return value

def _count(value):
    if type(value) is not int or value < 1 or value > 10000000:
        raise ReviewError('INVALID_LINE_COUNT')
    return value

def _hash(value):
    if not isinstance(value, str) or not re.fullmatch(r'[a-f0-9]{64}', value):
        raise ReviewError('INVALID_HASH')
    return value

def _ranges(value, total):
    if not isinstance(value, list) or len(value) > 10000:
        raise ReviewError('INVALID_RANGES')
    out = []
    last = 0
    for pair in value:
        if not isinstance(pair, list) or len(pair) != 2:
            raise ReviewError('INVALID_RANGE')
        start, end = pair
        if type(start) is not int or type(end) is not int or not 1 <= start <= end <= total or start <= last:
            raise ReviewError('INVALID_RANGE_ORDER_OR_BOUNDS')
        out.append((start, end))
        last = end
    return out

def _covers(known, required):
    for start, end in required:
        cursor = start
        for left, right in known:
            if right < cursor:
                continue
            if left > cursor:
                break
            cursor = max(cursor, right + 1)
            if cursor > end:
                break
        if cursor <= end:
            return False
    return True

def review_snapshot(source, review, required):
    """Inputs are caller assertions, not authenticated evidence or proof of reading.

    Line numbers are one-based and inclusive. Hash equality compares metadata;
    it does not read/hash files or validate their semantic content.
    """
    _keys(source, ['id', 'version', 'sha256', 'line_count'])
    _keys(review, ['source_id', 'version', 'sha256', 'line_count', 'ranges'])
    source_id = _text(source['id'])
    if _text(review['source_id']) != source_id:
        raise ReviewError('SOURCE_MISMATCH')
    version, reviewed_version = _text(source['version']), _text(review['version'])
    digest, reviewed_digest = _hash(source['sha256']), _hash(review['sha256'])
    total, reviewed_total = _count(source['line_count']), _count(review['line_count'])
    ranges = _ranges(review['ranges'], reviewed_total)
    needed = _ranges(required, total)
    if not needed:
        raise ReviewError('REQUIRED_RANGE_EMPTY')
    current = (version, digest, total) == (reviewed_version, reviewed_digest, reviewed_total)
    covered = current and _covers(ranges, needed)
    return {
        'source_id': source_id,
        'freshness': 'current' if current else 'stale',
        'requested_coverage': 'covered' if covered else ('missing' if current else 'unresolved_after_change'),
        'reviewed_lines_in_snapshot': sum(end - start + 1 for start, end in ranges),
        'whole_current_source_declared_reviewed': current and _covers(ranges, [(1, total)]),
        'eligible_as_current_source_note': covered,
        'proves_execution': False,
        'proves_semantic_truth': False,
        'publishes_content': False,
    }