@harmonyos-arkts/d2h 0.1.20 → 0.1.22

package/workflow/dashboard_overview.py

@@ -0,0 +1,109 @@
+"""Validate optional report inputs and project AppGraph notifications without changing execution."""
+import copy
+import hashlib
+import json
+import math
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def require(value, message):
+    if not value:
+        raise ValueError(message)
+
+
+def prepare(data, candidate):
+    if data is None:
+        return {'available': False, 'stale': False, 'code': None, 'tech_stack': [], 'dependencies': [], 'tools': []}
+    require(isinstance(data, dict) and data.get('schema') == 'd2h-overview/v1', 'd2h-overview/v1 required')
+    timestamp = datetime.fromisoformat(data['generated_at'].replace('Z', '+00:00'))
+    require(timestamp.tzinfo is not None, 'overview timestamp needs timezone')
+    sources = data.get('sources')
+    require(isinstance(sources, list), 'overview sources required')
+    checks, identities = [], set()
+    for source in sources:
+        require(isinstance(source, dict) and isinstance(source.get('source_id'), str) and bool(source['source_id']) and source['source_id'] not in identities, 'unique overview source_id required')
+        identities.add(source['source_id'])
+        path = Path(source['path'])
+        require(path.is_absolute() and isinstance(source.get('sha256'), str) and len(source['sha256']) == 64 and all(c in '0123456789abcdef' for c in source['sha256']), 'overview absolute source path and sha256 required')
+        try:
+            status = 'current' if hashlib.sha256(path.read_bytes()).hexdigest() == source['sha256'] else 'changed'
+        except OSError:
+            status = 'missing'
+        checks.append({'source_id': source['source_id'], 'status': status})
+
+    def refs(row):
+        values = row.get('source_refs')
+        require(isinstance(values, list) and bool(values) and all(isinstance(v, str) and v in identities for v in values), 'overview item needs known source_refs')
+
+    code = data.get('code')
+    if code is not None:
+        require(isinstance(code, dict), 'overview code must be an object')
+        refs(code)
+        for key in ('files', 'lines'):
+            require(code.get(key) is None or type(code[key]) is int and code[key] >= 0, 'nonnegative code counts or null required')
+        require(isinstance(code.get('method'), str) and bool(code['method'].strip()), 'code counting method required')
+        require(isinstance(code.get('languages', []), list), 'code languages must be an array')
+        for row in code.get('languages', []):
+            require(isinstance(row, dict) and isinstance(row.get('name'), str), 'language name required')
+            require(all(type(row.get(k)) is int and row[k] >= 0 for k in ('files', 'lines')), 'language file/line counts required')
+    for group in ('tech_stack', 'dependencies', 'tools', 'blockers'):
+        rows = data.get(group, [])
+        require(isinstance(rows, list), f'overview {group} must be an array')
+        for row in rows:
+            require(isinstance(row, dict) and isinstance(row.get('name'), str) and bool(row['name'].strip()), f'{group} item name required')
+            refs(row)
+            if group == 'blockers':
+                require(row.get('status') in ('open', 'resolved'), 'blocker status must be open/resolved')
+                require(isinstance(row.get('reason'), str) and bool(row['reason'].strip()), 'blocker reason required')
+            if group == 'dependencies':
+                require('blocking' not in row or type(row['blocking']) is bool, 'dependency blocking must be explicit boolean')
+                require(row.get('kind') in ('sdk', 'so', 'library'), 'dependency kind must be sdk/so/library')
+                require(row.get('provision') in ('self-build', 'provide-binary', 'platform-sdk', 'replace', 'unknown'), 'dependency provision decision required')
+                require(isinstance(row.get('reason'), str) and bool(row['reason'].strip()), 'dependency assessment reason required')
+            if group == 'tools':
+                require(row.get('status') in ('passed', 'failed', 'missing', 'unknown'), 'tool status must reflect actual check results')
+    result = copy.deepcopy(data)
+    result.update(available=True, source_checks=checks,
+                  stale=any(c['status'] != 'current' for c in checks) or 'candidate' in data and data['candidate'] != candidate)
+    return result
+
+
+def read_analysis(file, now=None):
+    if file is None:
+        return None
+    content = Path(file).read_text(encoding='utf-8')
+    # A concurrently appended last line is not an event until its newline is present.
+    lines = content.split('\n')[:-1]
+    run_id, sequence, latest, terminal = None, 0, None, None
+    warnings, summary_counts = [], None
+    for line in lines:
+        if not line.strip():
+            continue
+        event = json.loads(line)
+        require(event.get('schema') == 'appgraph-progress/v1', 'unsupported analysis progress schema')
+        require(isinstance(event.get('run_id'), str) and bool(event['run_id']), 'analysis run_id required')
+        if run_id is None:
+            run_id = event['run_id']
+        require(event['run_id'] == run_id, 'one AppGraph run per progress file required')
+        require(type(event.get('sequence')) is int and event['sequence'] == sequence + 1, 'analysis progress sequence gap')
+        require(terminal is None, 'analysis event after terminal event')
+        require(event.get('status') in ('started', 'progress', 'completed', 'warning', 'failed'), 'unknown analysis event status')
+        require(isinstance(event.get('phase'), str), 'analysis phase required')
+        for key in ('current', 'total'):
+            require(event.get(key) is None or type(event[key]) in (int, float) and math.isfinite(event[key]) and event[key] >= 0, 'invalid analysis count')
+        sequence, latest = event['sequence'], event
+        if event['status'] == 'warning':
+            warnings.append({k: event[k] for k in ('phase', 'message', 'counts') if k in event})
+        if event['status'] == 'completed' and isinstance(event.get('counts'), dict):
+            summary_counts = event['counts']
+        if event['phase'] == 'analysis' and event['status'] in ('completed', 'failed'):
+            terminal = event['status']
+    if latest is None:
+        return {'state': 'unknown', 'message': '暂无完整进度事件', 'latest': None, 'stale': True}
+    timestamp = datetime.fromisoformat(latest['timestamp'].replace('Z', '+00:00'))
+    require(timestamp.tzinfo is not None, 'analysis timestamp needs timezone')
+    age = max(0, ((now or datetime.now(timezone.utc)) - timestamp).total_seconds())
+    return {'state': terminal or ('failed' if latest['status'] == 'failed' else 'running'), 'latest': latest, 'run_id': run_id, 'sequence': sequence,
+            'warnings': warnings, 'summary_counts': summary_counts,
+            'age_seconds': round(age, 1), 'stale': terminal is None and age > 30}

package/workflow/delivery_view.py

@@ -0,0 +1,82 @@
+"""Read-only delivery projection. Acceptance always comes from spec_runtime.derive."""
+import json
+import hashlib
+
+LAYERS = ('mvp', 'core', 'full')
+
+
+def ratio(items):
+    total = len(items)
+    accepted = sum(bool(i['accepted']) for i in items)
+    percent = (100.0 if accepted == total else min(99.9, round(100 * accepted / total, 1))) if total else None
+    return {'total': total, 'accepted': accepted, 'percent': percent,
+            'unplanned': sum(i.get('spec_id') is None for i in items)}
+
+
+def progress(features, view):
+    if not view['scope_tracking']:
+        return {'configured': False, 'scope_tracking': False, 'selected': None, 'full': None, 'layers': {}}
+    rows = []
+    for feature in features['features']:
+        for item in view['feature_progress'][feature['feature_id']]['items']:
+            if feature['scope_status'] == 'excluded' or item['status'] == 'excluded':
+                continue
+            selected = feature['scope_status'] == 'included' and not feature['needs_clarification'] and item['status'] == 'included' and item['milestone'] != 'unassigned'
+            rows.append(dict(item, feature_id=feature['feature_id'], selected=selected))
+    config = features.get('delivery')
+    result = {'configured': config is not None, 'scope_tracking': True, 'target': config['target'] if config else None,
+              'customized': config['customized'] if config else None, 'selected': ratio([i for i in rows if i['selected']]),
+              'full': ratio(rows), 'layers': {}}
+    if config:
+        mapping = {(r['feature_id'], r['scope_id']): r['layer'] for r in config['scope_layers']}
+        for index, layer in enumerate(LAYERS):
+            result['layers'][layer] = {
+                'increment': ratio([i for i in rows if mapping[(i['feature_id'], i['scope_id'])] == layer]),
+                'cumulative': ratio([i for i in rows if mapping[(i['feature_id'], i['scope_id'])] in LAYERS[:index + 1]])}
+    return result
+
+
+def snapshot(plan, features, state, view, captured_at, baseline=None):
+    """Capture raw status and current proof together; baseline never substitutes for evidence."""
+    if view['running']:
+        activity = {'phase': 'implementation', 'label': '正在实施'}
+    elif view['validation_debt']['specs']:
+        activity = {'phase': 'verification', 'label': '有待验证或修复范围'}
+    elif state['candidate'] is None:
+        activity = {'phase': 'planning', 'label': '已有规划，尚未建立实现候选'}
+    else:
+        activity = {'phase': 'waiting', 'label': '当前无在途实现，等待下一步调度或 Review'}
+    before = {(f['feature_id'], i['scope_id']): i for f in (baseline or {}).get('features', []) for i in f.get('scope_items', [])}
+    current = {(f['feature_id'], i['scope_id']): (f, i) for f in features['features'] for i in f.get('scope_items', [])}
+    review = []
+    for key, (feature, item) in current.items():
+        derived = next((i for i in view['feature_progress'].get(key[0], {}).get('items', []) if i['scope_id'] == key[1]), {})
+        old = before.get(key)
+        difference = 'baseline-unavailable' if baseline is None else 'added' if old is None else 'changed' if any(old.get(k) != item.get(k) for k in ('description', 'acceptance')) else 'unchanged'
+        review.append({'feature_id': key[0], 'scope_id': key[1], 'description': item['description'], 'difference': difference,
+                       'status': item['status'], 'spec_id': derived.get('spec_id'), 'accepted': derived.get('accepted', False),
+                       'baseline': old, 'current': item, 'manual_review': 'pending'})
+    for key, item in before.items():
+        if key not in current:
+            review.append({'feature_id': key[0], 'scope_id': key[1], 'description': item['description'], 'difference': 'missing-from-current',
+                           'status': 'unknown', 'spec_id': None, 'accepted': False, 'baseline': item, 'current': None, 'manual_review': 'pending'})
+    starts = {}
+    for entry in state['events']:
+        event = entry['event']
+        if event['type'] == 'start':
+            starts[event['spec_id']] = entry['timestamp']
+    # A task clock is the elapsed dispatch interval, not accumulated worker effort.
+    timing = {'task_started_at': {sid: starts[sid] for sid in view['running'] if sid in starts}}
+    return {'schema': 'd2h-dashboard/v1', 'captured_at': captured_at, 'activity': activity, 'timing': timing, 'feature_plan': features, 'plan': plan,
+            'execution': {k: state[k] for k in ('schema', 'candidate', 'plan_hash', 'feature_hash', 'tasks')},
+            'event_sequence': len(state['events']), 'derived': view, 'review': {
+                'baseline_available': baseline is not None,
+                'baseline_revision': baseline['revision'] if baseline else None,
+                'baseline_hash': hashlib.sha256(json.dumps(baseline, sort_keys=True, ensure_ascii=False).encode()).hexdigest() if baseline else None,
+                'items': review}}
+
+
+def html(data, template):
+    # Payload may contain source/user text, including closing script tags.
+    payload = json.dumps(data, ensure_ascii=False).replace('<', '\\u003c').replace('\u2028', '\\u2028').replace('\u2029', '\\u2029')
+    return template.replace('/*__D2H_SNAPSHOT__*/null', payload)

package/workflow/feature_plan.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""Validate a feature planning handoff, without inferring feature semantics."""
+
+import importlib.util
+import argparse
+import json
+from pathlib import Path
+
+
+def validate_delivery(data, require):
+    """Optional, explicit scope tiers; scope_items remain the authorization source."""
+    delivery = data.get('delivery')
+    if delivery is None:
+        return
+    require(data.get('schema') == 'd2h-feature-plan/v2', 'delivery requires v2 scope tracking')
+    if not isinstance(delivery, dict):
+        require(False, 'delivery must be an object')
+        return
+    tiers = {'mvp': 0, 'core': 1, 'full': 2}
+    target = delivery.get('target')
+    require(isinstance(target, str) and target in tiers, 'delivery target must be mvp/core/full')
+    require(type(delivery.get('customized')) is bool, 'delivery customized must be boolean')
+    require(isinstance(delivery.get('reason'), str) and bool(delivery['reason'].strip()), 'delivery reason required')
+    feature_rows = data.get('features') if isinstance(data.get('features'), list) else []
+    items = {(f.get('feature_id'), i.get('scope_id')): (f, i) for f in feature_rows if isinstance(f, dict) and isinstance(f.get('scope_items'), list) for i in f['scope_items'] if isinstance(i, dict) and isinstance(f.get('feature_id'), str) and isinstance(i.get('scope_id'), str)}
+    remaining = {key for key, (f, i) in items.items() if f.get('scope_status') != 'excluded' and i.get('status') != 'excluded'}
+    rows = delivery.get('scope_layers')
+    require(isinstance(rows, list), 'delivery scope_layers must be an array')
+    mapping = {}
+    for row in rows if isinstance(rows, list) else []:
+        if not isinstance(row, dict) or not isinstance(row.get('feature_id'), str) or not isinstance(row.get('scope_id'), str):
+            require(False, 'delivery needs feature_id/scope_id references')
+            continue
+        key = (row['feature_id'], row['scope_id'])
+        require(key in items, 'delivery references unknown scope')
+        require(key not in mapping, 'delivery scope mapped more than once')
+        layer = row.get('layer')
+        require(isinstance(layer, str) and layer in tiers, 'delivery layer must be mvp/core/full')
+        mapping[key] = layer if isinstance(layer, str) else None
+    require(remaining <= mapping.keys(), 'delivery must map every non-excluded scope, including deferred/unresolved')
+    if delivery.get('customized') is False and isinstance(target, str) and target in tiers:
+        expected = {key for key in remaining if tiers.get(mapping.get(key), 99) <= tiers[delivery['target']]}
+        selected = {key for key in remaining if items[key][0].get('scope_status') == 'included' and not items[key][0].get('needs_clarification') and items[key][1].get('status') == 'included' and items[key][1].get('milestone') != 'unassigned'}
+        require(expected == selected, 'delivery preset must match authorized scope; use customized=true for local adjustments')
+
+
+def validate(data, previous=None, check_analysis=True, require_delivery=False):
+    errors = []
+
+    def require(condition, message):
+        if not condition:
+            errors.append(message)
+
+    def text(value):
+        return isinstance(value, str) and bool(value.strip())
+
+    def records(key, id_key):
+        items = data.get(key)
+        if not isinstance(items, list):
+            errors.append(f"{key} must be an array")
+            return {}
+        result = {}
+        for item in items:
+            if not isinstance(item, dict) or not text(item.get(id_key)):
+                errors.append(f"{key} entries require {id_key}")
+                continue
+            identity = item[id_key]
+            require(identity not in result, f"duplicate {id_key}: {identity}")
+            result[identity] = item
+        return result
+
+    if not isinstance(data, dict):
+        return ["plan must be an object"]
+    require(data.get("schema") in {"d2h-feature-plan/v1", "d2h-feature-plan/v2"}, "unsupported schema")
+    revision = data.get("revision")
+    require(type(revision) is int and revision > 0, "revision must be a positive integer")
+    sources = records("sources", "source_id")
+    milestones = records("milestones", "milestone_id")
+    features = records("features", "feature_id")
+    require("unassigned" not in milestones, "unassigned is a reserved milestone")
+    for identity, source in sources.items():
+        require(source.get("kind") in {"facts", "utg", "inventory", "source", "user"}, f"{identity}: invalid source kind")
+        require(text(source.get("locator")) and text(source.get("revision")), f"{identity}: locator and revision required")
+    for identity, milestone in milestones.items():
+        require(text(milestone.get("title")), f"{identity}: title required")
+        checks = milestone.get("acceptance")
+        require(isinstance(checks, list) and bool(checks) and all(text(c) for c in checks), f"{identity}: acceptance required")
+
+    graph = {}
+    for identity, feature in features.items():
+        require(text(feature.get("title")), f"{identity}: title required")
+        origin = feature.get("origin")
+        require(origin in {"extracted", "user", "merged"}, f"{identity}: invalid origin")
+        refs = feature.get("source_refs")
+        kinds = set()
+        require(isinstance(refs, list) and bool(refs), f"{identity}: source_refs required")
+        for ref in refs if isinstance(refs, list) else []:
+            if not isinstance(ref, dict) or not text(ref.get("ref")) or ref.get("source_id") not in sources:
+                errors.append(f"{identity}: invalid source reference")
+                continue
+            kind = sources[ref["source_id"]].get("kind")
+            if isinstance(kind, str):
+                kinds.add(kind)
+        if origin in {"user", "merged"}:
+            require("user" in kinds, f"{identity}: user provenance required")
+        if origin in {"extracted", "merged"}:
+            require(bool(kinds - {"user"}), f"{identity}: extracted provenance required")
+        require(feature.get("user_priority") in {"must", "normal", "later"}, f"{identity}: invalid priority")
+        status = feature.get("scope_status")
+        require(status in {"included", "deferred", "excluded"}, f"{identity}: invalid scope status")
+        if status in {"deferred", "excluded"}:
+            require(text(feature.get("reason")), f"{identity}: scope change reason required")
+        require(feature.get("milestone") in [*milestones, "unassigned"], f"{identity}: unknown milestone")
+        for key in (("required_scope", "acceptance") if data.get("schema") == "d2h-feature-plan/v1" else ("acceptance",)):
+            values = feature.get(key)
+            require(isinstance(values, list) and bool(values) and all(text(v) for v in values), f"{identity}: {key} must be nonempty strings")
+        deferred = feature.get("deferred_scope", [])
+        require(isinstance(deferred, list), f"{identity}: deferred_scope must be an array")
+        for item in deferred if isinstance(deferred, list) else []:
+            require(isinstance(item, dict) and text(item.get("description")) and item.get("target_milestone") in [*milestones, "unassigned"], f"{identity}: invalid deferred scope")
+        if data.get("schema") == "d2h-feature-plan/v2":
+            items = feature.get("scope_items")
+            require(isinstance(items, list) and bool(items), f"{identity}: scope_items required")
+            seen = set()
+            for item in items if isinstance(items, list) else []:
+                if not isinstance(item, dict) or not text(item.get("scope_id")):
+                    errors.append(f"{identity}: scope_id required")
+                    continue
+                scope_id = item["scope_id"]
+                require(scope_id not in seen, f"{identity}: duplicate scope_id {scope_id}")
+                seen.add(scope_id)
+                require(text(item.get("description")), f"{identity}/{scope_id}: description required")
+                require(item.get("status") in {"included", "deferred", "excluded", "unresolved"}, f"{identity}/{scope_id}: invalid scope status")
+                require(item.get("milestone") in [*milestones, "unassigned"], f"{identity}/{scope_id}: unknown milestone")
+                require(isinstance(item.get("acceptance"), list) and bool(item["acceptance"]) and all(text(v) for v in item["acceptance"]), f"{identity}/{scope_id}: acceptance required")
+                if item.get("status") != "included":
+                    require(text(item.get("reason")), f"{identity}/{scope_id}: disposition reason required")
+            require("required_scope" not in feature and "deferred_scope" not in feature, f"{identity}: v2 uses scope_items as sole scope source")
+        derived = feature.get("derived_from")
+        require(isinstance(derived, list) and all(text(v) and v != identity for v in derived), f"{identity}: invalid derived_from")
+        require(type(feature.get("needs_clarification")) is bool, f"{identity}: needs_clarification must be boolean")
+        targets = feature.get("requested_before")
+        require(isinstance(targets, list), f"{identity}: requested_before must be an array")
+        graph[identity] = []
+        for target in targets if isinstance(targets, list) else []:
+            if not text(target) or target not in features or target == identity:
+                errors.append(f"{identity}: invalid requested_before target: {target}")
+                continue
+            require(feature.get("milestone") == features[target].get("milestone"), f"{identity}: ordering crosses milestones: {target}")
+            graph[identity].append(target)
+
+    validate_delivery(data, require)
+    if require_delivery and not errors:
+        delivery = data.get('delivery')
+        require(isinstance(delivery, dict), 'usable delivery presets require explicit delivery configuration')
+        if isinstance(delivery, dict):
+            eligible = {(f.get('feature_id'), i.get('scope_id')) for f in features.values() if f.get('scope_status') != 'excluded' for i in f.get('scope_items', []) if i.get('status') != 'excluded'}
+            rows = delivery.get('scope_layers')
+            for index, target in enumerate(('mvp', 'core', 'full')):
+                layers = ('mvp', 'core', 'full')[:index + 1]
+                keys = {(r.get('feature_id'), r.get('scope_id')) for r in rows if isinstance(r, dict) and r.get('layer') in layers} if isinstance(rows, list) else set()
+                require(bool(keys & eligible), f'{target} preset has no selectable scope; assess scope_layers instead of assigning every item to full')
+
+    # Iterative topological check supports large inventories without recursion limits.
+    indegree = dict.fromkeys(graph, 0)
+    for targets in graph.values():
+        for target in targets:
+            indegree[target] += 1
+    ready = [key for key, degree in indegree.items() if degree == 0]
+    visited = 0
+    while ready:
+        visited += 1
+        for target in graph[ready.pop()]:
+            indegree[target] -= 1
+            if indegree[target] == 0:
+                ready.append(target)
+    require(visited == len(graph), "requested_before contains a cycle")
+    changes = data.get("changes")
+    require(isinstance(changes, list), "changes must be an array")
+    for change in changes if isinstance(changes, list) else []:
+        if not isinstance(change, dict):
+            errors.append("invalid change record")
+            continue
+        number = change.get("revision")
+        require(type(number) is int and type(revision) is int and 1 <= number <= revision, "invalid change revision")
+        require(change.get("actor") in {"user", "ai", "import"} and text(change.get("summary")), "change actor and summary required")
+        ids = change.get("feature_ids")
+        require(isinstance(ids, list) and all(text(v) and v in features for v in ids), "change references unknown features")
+    require(isinstance(data.get("open_questions"), list), "open_questions must be an array")
+    if previous is not None:
+        if not isinstance(previous, dict) or (previous.get("schema"), data.get("schema")) not in {("d2h-feature-plan/v1", "d2h-feature-plan/v1"), ("d2h-feature-plan/v1", "d2h-feature-plan/v2"), ("d2h-feature-plan/v2", "d2h-feature-plan/v2")}:
+            errors.append("unsupported feature schema transition")
+        else:
+            old_revision = previous.get("revision")
+            if data != previous:
+                require(type(revision) is int and type(old_revision) is int and revision == old_revision + 1, "changed plan must increment revision by one")
+                require(isinstance(changes, list) and any(isinstance(c, dict) and c.get("revision") == revision for c in changes), "changed plan needs a current revision event")
+            old_changes = previous.get("changes", [])
+            require(isinstance(changes, list) and changes[:len(old_changes)] == old_changes, "previous change history must be preserved")
+            for feature in features.values():
+                old = next((f for f in previous.get("features", []) if f.get("feature_id") == feature["feature_id"]), {})
+                old_scope = {v["scope_id"] for v in old.get("scope_items", [])}
+                new_scope = {v["scope_id"] for v in feature.get("scope_items", [])}
+                require(old_scope <= new_scope, "previous scope IDs must be retained; exclude replaced scope items")
+            old_ids = {f["feature_id"] for f in previous.get("features", []) if isinstance(f, dict) and text(f.get("feature_id"))}
+            require(old_ids <= features.keys(), "previous feature IDs must be retained; exclude replaced features")
+    if not errors and check_analysis:
+        loader = importlib.util.spec_from_file_location('analysis_handoff', Path(__file__).with_name('artifact_bindings.py'))
+        handoff = importlib.util.module_from_spec(loader)
+        loader.loader.exec_module(handoff)
+        errors.extend(handoff.validate_links(data))
+    return errors
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("plan", type=Path)
+    parser.add_argument("--previous", type=Path)
+    parser.add_argument("--require-delivery", action="store_true", help="Require explicit, nonempty MVP/core/full cumulative presets")
+    args = parser.parse_args()
+    try:
+        data = json.loads(args.plan.read_text(encoding="utf-8"))
+        previous = json.loads(args.previous.read_text(encoding="utf-8")) if args.previous else None
+        errors = validate(data, previous, require_delivery=args.require_delivery)
+    except (OSError, ValueError) as error:
+        errors = [str(error)]
+    for error in errors:
+        print(f"ERROR: {error}")
+    print(json.dumps({"errors": len(errors)}, ensure_ascii=False))
+    return bool(errors)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())