# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/permanent-labor-market-collapse-and-concentrated-power.md
# Remnant Warrant:    https://corpusfetch.com/c/permanent-labor-market-collapse-and-concentrated-power.warrant.json
# Markdown SHA-256:   7f87caee16e5a10bf26e795bae3a2fa61d61b39b75f2485cfed3a6f20a7d146e
# Code AST SHA-256:   e5bd77ef510b08e383a97fa2a8653f2c8a91315bcc360d8b8faa474e1d22e60e
# Verified Classes:   VendorLockInOrPortabilityError, SovereigntyAuditReport, ArchitecturalSovereigntyGate
# Defensive Guards:   2 fail-closed invariants (zero external deps)

import ast
import sys
from dataclasses import dataclass
from typing import Final


class VendorLockInOrPortabilityError(ValueError):
    '''Raised when a reference pattern introduces unapproved proprietary dependencies or lacks open state export.'''
    pass


@dataclass(frozen=True)
class SovereigntyAuditReport:
    module_name: str
    uses_only_stdlib: bool
    external_imports: tuple[str, ...]
    open_format_state_export: bool
    single_operator_maintainable: bool


class ArchitecturalSovereigntyGate:
    '''
    Verifies that generated reference implementations and architectures counteract
    centralized lock-in by enforcing:
    1. Pure Python standard-library execution (`sys.stdlib_module_names`) for core reference Methods.
    2. Open, human-inspectable serialization formats (JSON, SQLite, CSV, Markdown).
    3. Zero undocumented proprietary runtime dependencies.
    '''

    OPEN_STATE_FORMATS: Final[frozenset[str]] = frozenset({"json", "sqlite", "markdown", "csv", "tsv", "posix_file"})

    @classmethod
    def audit_python_reference_portability(
        cls,
        *,
        module_name: str,
        python_source: str,
        state_storage_format: str,
    ) -> SovereigntyAuditReport:
        tree = ast.parse(python_source)
        stdlib_names = sys.stdlib_module_names
        non_stdlib: set[str] = set()

        for node in ast.walk(tree):
            if isinstance(node, ast.Import):
                for alias in node.names:
                    root_pkg = alias.name.split(".")[0]
                    if root_pkg not in stdlib_names:
                        non_stdlib.add(root_pkg)
            elif isinstance(node, ast.ImportFrom) and node.module:
                root_pkg = node.module.split(".")[0]
                if node.level == 0 and root_pkg not in stdlib_names:
                    non_stdlib.add(root_pkg)

        if non_stdlib:
            raise VendorLockInOrPortabilityError(
                f"Reference module '{module_name}' imports non-stdlib packages {sorted(non_stdlib)}. "
                "Core MethodFetch patterns must remain dependency-free and sovereignly runnable."
            )

        norm_fmt = state_storage_format.strip().lower()
        if norm_fmt not in cls.OPEN_STATE_FORMATS:
            raise VendorLockInOrPortabilityError(
                f"State format '{state_storage_format}' is not in the open portable set {sorted(cls.OPEN_STATE_FORMATS)}."
            )

        return SovereigntyAuditReport(
            module_name=module_name,
            uses_only_stdlib=True,
            external_imports=(),
            open_format_state_export=True,
            single_operator_maintainable=True,
        )