cf-bootstrap-instance 0.1.8__py3-none-any.whl

cf_bootstrap_instance/verify.py

@@ -0,0 +1,358 @@
+"""Independent target-environment inventory, provenance, and semantic checks."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import re
+
+from .model import InstanceError
+from .process import run
+
+
+_CHECK = r'''
+import json, os, pathlib, stat, subprocess, sys
+from importlib import metadata
+
+environment = pathlib.Path(sys.argv[1]).resolve()
+expected = json.loads(sys.argv[2])
+checkout = pathlib.Path(sys.argv[3]).resolve() if sys.argv[3] else None
+native_expected = json.loads(sys.argv[5])
+native_by_name = {item["name"]: item for item in native_expected}
+site = pathlib.Path(next(item for item in sys.path if item and "site-packages" in pathlib.Path(item).parts)).resolve()
+scripts = environment / ("Scripts" if sys.platform == "win32" else "bin")
+if pathlib.Path(sys.executable).resolve() != pathlib.Path(sys.argv[4]).resolve() or pathlib.Path(sys.prefix).resolve() != environment:
+    raise RuntimeError("target interpreter is not bound to the target environment")
+if checkout and any(pathlib.Path(item).resolve() == checkout or checkout in pathlib.Path(item).resolve().parents for item in sys.path):
+    raise RuntimeError("checkout appears in target sys.path")
+
+distributions = list(metadata.distributions())
+actual = sorted([{"name": d.metadata.get("Name"), "version": d.version} for d in distributions], key=lambda item: item["name"].lower())
+if actual != expected:
+    raise RuntimeError("installed distribution inventory differs from artifact set")
+for distribution in distributions:
+    location = pathlib.Path(distribution.locate_file("")).resolve()
+    if site not in location.parents and location != site:
+        raise RuntimeError("distribution is outside target site-packages")
+    for file in distribution.files or ():
+        path = (location / file).resolve()
+        if site not in path.parents and path != site and scripts not in path.parents:
+            raise RuntimeError("distribution file escaped site-packages")
+    for file in distribution.files or ():
+        if file.name in ("direct_url.json",) or file.suffix == ".pth" or file.name.endswith(".egg-link"):
+            raise RuntimeError("forbidden editable/provenance metadata found")
+    for entry in distribution.entry_points:
+        if entry.group == "console_scripts":
+            command = scripts / entry.name
+            if sys.platform == "win32":
+                command = command.with_suffix(".exe")
+            if not command.is_file() or command.resolve().parent != scripts.resolve():
+                raise RuntimeError("console script is not in target Scripts directory")
+
+semantic_entries = list(metadata.entry_points(group="cogniflow.semantic_sources"))
+by_distribution = {}
+semantic_files = {}
+for entry in semantic_entries:
+    dist = entry.dist
+    if dist is None or not dist.metadata.get("Name") or entry.name in by_distribution:
+        raise RuntimeError("semantic source entry point is ambiguous")
+    by_distribution[entry.name] = entry
+for expected_item in expected:
+    name = expected_item["name"]
+    if name in native_by_name or name == "cf-service-mcp-server":
+        continue
+    if not (name.lower().startswith("cf-") or name.lower() == "cogniflow"):
+        continue
+    matches = [entry for entry in semantic_entries if entry.dist.metadata.get("Name") == name]
+    if len(matches) != 1:
+        raise RuntimeError(f"expected distribution has no unique semantic source: {name}")
+    files = matches[0].load()()
+    if not files:
+        raise RuntimeError("semantic source is empty")
+    for file in files:
+        path = pathlib.Path(file).resolve()
+        if site not in path.parents or not path.is_file() or path.suffix != ".trig":
+            raise RuntimeError(f"semantic source escaped target package: {path} (site={site})")
+    semantic_files[name] = [str(path) for path in files]
+
+for item in native_expected:
+    name = item["name"]
+    distribution = metadata.distribution(name)
+    if distribution.version != item["version"]:
+        raise RuntimeError("native distribution version differs from artifact metadata")
+    command = scripts / pathlib.PurePosixPath(item["executable"]).name
+    try:
+        info = command.lstat()
+    except OSError as error:
+        raise RuntimeError("native executable is missing") from error
+    if command.is_symlink() or not stat.S_ISREG(info.st_mode) or (sys.platform == "win32" and getattr(info, "st_file_attributes", 0) & 0x400):
+        raise RuntimeError("native executable is not a regular target file")
+    binary = command.read_bytes()
+    if (sys.platform == "win32" and not binary.startswith(b"MZ")) or (sys.platform != "win32" and not binary.startswith(b"\x7fELF")):
+        raise RuntimeError("installed native executable has the wrong file type")
+    version_env = os.environ.copy()
+    version_env.pop("COGNIFLOW_RUNTIME_MANIFEST", None)
+    version_env["PATH"] = str(scripts)
+    version_env["CARGO_HOME"] = str(environment / "missing-cargo-home")
+    version_env["RUSTUP_HOME"] = str(environment / "missing-rustup-home")
+    version_env.pop("RUSTUP_TOOLCHAIN", None)
+    result = subprocess.run([str(command), "--version"], cwd=environment, env=version_env, capture_output=True, text=True, check=False, timeout=10)
+    if result.returncode != 0 or result.stderr or result.stdout != f"{name} {item['version']}\n":
+        raise RuntimeError("installed native executable version check failed")
+semantic_files["__native__"] = native_expected
+print(json.dumps({"inventory": actual, "semantic_files": semantic_files}, sort_keys=True))
+'''
+
+
+def inventory(executable: Path, environment: Path, artifact_set: dict[str, object], checkout: Path | None = None) -> list[dict[str, str]]:
+    expected = sorted([{"name": item["distribution"], "version": item["version"]} for item in artifact_set["artifacts"]], key=lambda item: item["name"].lower())
+    native_expected = [{"name": item["distribution"], "version": item["version"], "executable": item["executable"]} for item in artifact_set["artifacts"] if item.get("artifact_kind") == "native"]
+    result = run([str(executable), "-c", _CHECK, str(environment), json.dumps(expected, sort_keys=True), str(checkout or ""), str(executable), json.dumps(native_expected, sort_keys=True)], timeout=60, cwd=environment)
+    try:
+        report = json.loads(result.stdout)
+        actual = report["inventory"]
+    except ValueError as error:
+        raise InstanceError("VERIFY_FAILED", "target verification was not JSON") from error
+    if actual != expected:
+        raise InstanceError("VERIFY_FAILED", "target inventory differs from expected inventory")
+    _verify_semantics(report["semantic_files"], expected)
+    return actual
+
+
+def _verify_semantics(files_by_distribution: object, expected: list[dict[str, str]]) -> None:
+    if not isinstance(files_by_distribution, dict):
+        raise InstanceError("VERIFY_FAILED", "semantic source report is invalid")
+    try:
+        from rdflib import Dataset, Literal, URIRef
+    except ModuleNotFoundError:
+        _verify_semantics_without_rdflib(files_by_distribution, expected)
+        return
+    cf = URIRef("https://cogniflow.odea-project.org/cf#")
+    rdf_type = URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
+    rdf_value = URIRef("http://www.w3.org/1999/02/22-rdf-syntax-ns#value")
+    def objects(subject: object, predicate: object) -> list[object]:
+        return [obj for _, _, obj, _ in dataset.quads((subject, predicate, None, None))]
+    def subjects(predicate: object, obj: object) -> list[object]:
+        return [subject for subject, _, _, _ in dataset.quads((None, predicate, obj, None))]
+    for item in expected:
+        name = item["name"]
+        if name == "cf-service-mcp-server" or any(item.get("name") == name for item in files_by_distribution.get("__native__", [])):
+            continue
+        if not (name.lower().startswith("cf-") or name.lower() == "cogniflow"):
+            continue
+        files = files_by_distribution.get(name)
+        if not isinstance(files, list) or not files:
+            raise InstanceError("VERIFY_FAILED", f"semantic source is empty for {name}")
+        package_files = [Path(file) for file in files if Path(file).name == "package.trig"]
+        if len(package_files) != 1:
+            raise InstanceError("VERIFY_FAILED", f"semantic package manifest is not unique for {name}")
+        path = package_files[0]
+        try:
+            dataset = Dataset()
+            dataset.parse(path.as_posix(), format="trig")
+        except Exception as error:
+            raise InstanceError("VERIFY_FAILED", "semantic TriG is not parseable") from error
+        packages = subjects(rdf_type, cf + "CfPackage")
+        if len(packages) != 1:
+            raise InstanceError("VERIFY_FAILED", "semantic source does not contain exactly one CfPackage")
+        manifests = objects(packages[0], cf + "hasPackageManifest")
+        if len(manifests) != 1:
+            raise InstanceError("VERIFY_FAILED", "semantic source has no unique package manifest")
+        distributions = objects(manifests[0], cf + "hasDistributionName")
+        versions = objects(manifests[0], cf + "hasPackageVersion")
+        values = objects(distributions[0], rdf_value) if len(distributions) == 1 else []
+        version_values = objects(versions[0], rdf_value) if len(versions) == 1 else []
+        if values != [Literal(name)] or version_values != [Literal(item["version"])] or path.name != "package.trig":
+            raise InstanceError("VERIFY_FAILED", "semantic package manifest does not match distribution")
+
+
+def _verify_semantics_without_rdflib(files_by_distribution: dict[str, object], expected: list[dict[str, str]]) -> None:
+    """Keep installed-provider verification dependency-free when rdflib is absent."""
+    for item in expected:
+        name = item["name"]
+        if any(item.get("name") == name for item in files_by_distribution.get("__native__", [])):
+            continue
+        if not (name.lower().startswith("cf-") or name.lower() == "cogniflow"):
+            continue
+        files = files_by_distribution.get(name)
+        if not isinstance(files, list) or not files:
+            raise InstanceError("VERIFY_FAILED", f"semantic source is empty for {name}")
+        package_files = [Path(file) for file in files if Path(file).name == "package.trig"]
+        if len(package_files) != 1:
+            raise InstanceError("VERIFY_FAILED", f"semantic package manifest is not unique for {name}")
+        path = package_files[0]
+        if not path.is_file():
+            raise InstanceError("VERIFY_FAILED", "semantic source is not a package.trig file")
+        text = path.read_text(encoding="utf-8")
+        if not _minimal_trig_structure(text, name, item["version"]):
+            raise InstanceError("VERIFY_FAILED", "semantic source is missing required manifest data")
+
+
+def _minimal_trig_structure(text: str, name: str, version: str) -> bool:
+    """Parse the strict package-manifest TriG subset without rdflib."""
+    prefixes, body = _parse_prefixes(text)
+    if prefixes is None:
+        return False
+    tokens = _trig_tokens(body)
+    if tokens is None:
+        return False
+    parser = _ManifestParser(tokens, name, version)
+    return parser.parse() and parser.position == len(tokens)
+
+
+def _parse_prefixes(text: str) -> tuple[dict[str, str], str] | tuple[None, str]:
+    prefix_pattern = re.compile(r"@prefix ([A-Za-z_][A-Za-z0-9_-]*): <([^>]+)> \.")
+    prefixes: dict[str, str] = {}
+    lines = text.splitlines()
+    body_start = 0
+    for index, line in enumerate(lines):
+        if not line.strip():
+            continue
+        match = prefix_pattern.fullmatch(line.strip())
+        if match is None:
+            body_start = index
+            break
+        prefix, namespace = match.groups()
+        if prefix in prefixes or prefix not in {"cf", "cfproc", "cfservice", "cfpkg", "rdf", "pkg", "contribution", "dcterms", "skos", "xsd"}:
+            return None, ""
+        prefixes[prefix] = namespace
+        body_start = index + 1
+    expected = {"cf": "https://cogniflow.odea-project.org/cf#", "cfproc": "https://cogniflow.odea-project.org/cf#", "cfservice": "https://cogniflow.odea-project.org/cf#", "cfpkg": "https://cogniflow.odea-project.org/cf#", "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#", "pkg": "urn:cf:pkg:", "contribution": "urn:cf:contribution:", "dcterms": "http://purl.org/dc/terms/", "skos": "http://www.w3.org/2004/02/skos/core#", "xsd": "http://www.w3.org/2001/XMLSchema#"}
+    if any(prefix in prefixes and prefixes[prefix] != value for prefix, value in expected.items()) or not {"cfpkg", "rdf", "pkg"} <= prefixes.keys():
+        return None, ""
+    return prefixes, "\n".join(lines[body_start:])
+
+
+def _trig_tokens(text: str) -> list[str] | None:
+    token_pattern = re.compile(r'\s+|"(?:\\.|[^"\\])*"(?:\^\^[A-Za-z_][A-Za-z0-9_.-]*:[A-Za-z0-9_.-]+)?|<[^>]*>|[{}\[\];.]|[A-Za-z_][A-Za-z0-9_.-]*:[A-Za-z0-9_.-]+|a\b')
+    tokens: list[str] = []
+    position = 0
+    while position < len(text):
+        match = token_pattern.match(text, position)
+        if match is None:
+            return None
+        token = match.group(0)
+        if not token.isspace():
+            tokens.append(token)
+        position = match.end()
+    return tokens
+
+
+class _ManifestParser:
+    _manifest_fields = {"cfpkg:hasDistributionName": "DistributionName", "cfpkg:hasPythonPackageName": "PythonPackageName", "cfpkg:hasPackageVersion": "PackageVersion", "cfpkg:hasImplementationLanguage": "ImplementationLanguage"}
+    _top_fields = {"cfpkg:hasPackageRole", "cfpkg:hasPackageContribution", "skos:prefLabel", "skos:definition", "skos:scopeNote", "skos:example", "dcterms:created"}
+
+    def __init__(self, tokens: list[str], name: str, version: str) -> None:
+        self.tokens = tokens
+        self.position = 0
+        self.name = name
+        self.version = version
+
+    def take(self) -> str | None:
+        if self.position >= len(self.tokens):
+            return None
+        token = self.tokens[self.position]
+        self.position += 1
+        return token
+
+    def expect(self, expected: str) -> bool:
+        return self.take() == expected
+
+    def parse(self) -> bool:
+        if self.tokens.count("cfpkg:CfPackage") != 1:
+            return False
+        graph = self.take()
+        if graph is None or not graph.startswith("pkg:") or not self.expect("{") or self.take() != graph or not self.expect("a") or not self.expect("cfpkg:CfPackage") or not self.expect(";"):
+            return False
+        manifest_count = 0
+        package_terminated = False
+        while self.position < len(self.tokens) and self.tokens[self.position] != "}":
+            predicate = self.take()
+            if predicate == "cfpkg:hasPackageManifest":
+                manifest_count += 1
+                if not self.parse_manifest():
+                    return False
+            elif predicate in self._top_fields:
+                if not self.skip_object():
+                    return False
+            else:
+                return False
+            terminator = self.take()
+            if terminator not in {";", "."}:
+                return False
+            if terminator == ".":
+                package_terminated = True
+                break
+        if not package_terminated or manifest_count != 1:
+            return False
+        while self.position < len(self.tokens) and self.tokens[self.position] != "}":
+            if self.take() is None or not self.expect("a") or self.take() is None or not self.expect(";"):
+                return False
+            statement_terminated = False
+            while self.position < len(self.tokens):
+                if self.tokens[self.position] == ".":
+                    self.take()
+                    statement_terminated = True
+                    break
+                if self.tokens[self.position] == "}":
+                    return False
+                if self.take() is None or not self.skip_object():
+                    return False
+                terminator = self.take()
+                if terminator not in {";", "."}:
+                    return False
+                if terminator == ".":
+                    statement_terminated = True
+                    break
+            if not statement_terminated:
+                return False
+        return self.expect("}")
+
+    def parse_manifest(self) -> bool:
+        if not self.expect("[") or not self.expect("a") or not self.expect("cfpkg:PackageManifest") or not self.expect(";"):
+            return False
+        fields: dict[str, str] = {}
+        closed = False
+        while self.position < len(self.tokens) and self.tokens[self.position] != "]":
+            predicate = self.take()
+            expected_type = self._manifest_fields.get(predicate or "")
+            if expected_type is None or predicate in fields:
+                return False
+            value = self.parse_value_resource(expected_type)
+            if value is None:
+                return False
+            fields[predicate] = value
+            terminator = self.take()
+            if terminator not in {";", "]"}:
+                return False
+            if terminator == "]":
+                closed = True
+                break
+        required = {"cfpkg:hasDistributionName", "cfpkg:hasPackageVersion", "cfpkg:hasImplementationLanguage"}
+        if not closed and self.expect("]"):
+            closed = True
+        return closed and required <= fields.keys() and fields["cfpkg:hasDistributionName"] == self.name and fields["cfpkg:hasPackageVersion"] == self.version and fields["cfpkg:hasImplementationLanguage"] == "Python"
+
+    def parse_value_resource(self, expected_type: str) -> str | None:
+        if not self.expect("[") or not self.expect("a") or not self.expect(f"cfpkg:{expected_type}") or not self.expect(";") or not self.expect("rdf:value"):
+            return None
+        value = self.take()
+        if value is None or not value.startswith('"') or not self.expect("]"):
+            return None
+        return value[1:-1]
+
+    def skip_object(self) -> bool:
+        if self.position >= len(self.tokens):
+            return False
+        if self.tokens[self.position] != "[":
+            return self.take() is not None
+        depth = 0
+        while self.position < len(self.tokens):
+            token = self.take()
+            if token == "[":
+                depth += 1
+            elif token == "]":
+                depth -= 1
+                if depth == 0:
+                    return True
+        return False

cf_bootstrap_instance-0.1.8.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: cf-bootstrap-instance
+Version: 0.1.8
+Summary: Stable, non-editable Cogniflow instance environment bootstrapper.
+Requires-Python: >=3.11
+Requires-Dist: cf-service-client==0.1.8

cf_bootstrap_instance-0.1.8.dist-info/RECORD

@@ -0,0 +1,18 @@
+cf_bootstrap_instance/__init__.py,sha256=w8v2lK8uQkR8mUszqfItidsgEARz1GerYfqd1Sy_ELw,300
+cf_bootstrap_instance/handoff.py,sha256=YeevOTt8sfp0yuZlhyP-sKS8Q20p04VjdB3ju2YzO1M,10504
+cf_bootstrap_instance/install.py,sha256=MM6ASCEEL7wIczn_HTNcGws9UkV_8dQ15jcbdKV5GS4,5393
+cf_bootstrap_instance/layout.py,sha256=doBDoAOmrmEJ9BS6i0Ocsy2ETjdIuIfddPsJqx5l2QQ,8581
+cf_bootstrap_instance/model.py,sha256=D3I8X0D-MbNFPI-uzZQr_uTeZ3-WF7B4-j9itgXuV3Y,24606
+cf_bootstrap_instance/process.py,sha256=_ZtyZF6RP2PHn3WcMuxA1wUzE7JKNiqXaSwdsgBliE0,2007
+cf_bootstrap_instance/provider.py,sha256=9B0L4sm8NAODZ8veTL4bUG7xRjjdKJtv6pml7XIbZJU,41754
+cf_bootstrap_instance/recovery.py,sha256=Q1iD3l4jJXV6JIj6IE4hERB_A4BzBR5DbbBJEcNe2J0,21703
+cf_bootstrap_instance/service_executor.py,sha256=Wk2JYPRS4F5D5pg08RYouOiGcP3Ml5Y5ggS8zVmqD68,12139
+cf_bootstrap_instance/transition_authority.py,sha256=CWDdUhnWgOK1OSglq3g7F26Gh8i5-gKHCYSlqrAp200,8471
+cf_bootstrap_instance/uninstall_authority.py,sha256=EXUl3P0lL4LPRlUYvTw9qxRCKk4e237tWuWiCj3Cw9E,6134
+cf_bootstrap_instance/verify.py,sha256=H5zHj59uu5uTY81RJZ6zvYd0QeqHfVMWXrLRq19To9Q,18836
+cf_bootstrap_instance/semantics/package.trig,sha256=JORaCC2YX_8TkTV457YbZmh2i8x5z0EJAGz-s1ufkow,1436
+cf_bootstrap_instance/semantics/service.trig,sha256=-27WTCCrUxubqyFF76s66Vv3fT7bofjRCfZyBCY9adY,13321
+cf_bootstrap_instance-0.1.8.dist-info/METADATA,sha256=GNW6wI6En6k3f-sQfakys2wBFg_kb6ZoCwErSKUPx_s,204
+cf_bootstrap_instance-0.1.8.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+cf_bootstrap_instance-0.1.8.dist-info/entry_points.txt,sha256=tcUsw9ZwYrt2PcaU1vxfybowlsvbWvRF5y7cNJiL3Zk,415
+cf_bootstrap_instance-0.1.8.dist-info/RECORD,,

cf_bootstrap_instance-0.1.8.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cf_bootstrap_instance-0.1.8.dist-info/entry_points.txt

@@ -0,0 +1,10 @@
+[console_scripts]
+cf-bootstrap-instance-handoff = cf_bootstrap_instance.handoff:main
+cf-bootstrap-instance-provider = cf_bootstrap_instance.provider:main
+cf-bootstrap-runtime-repair = cf_bootstrap_instance.recovery:main
+
+[cogniflow.instance_providers.v1]
+cf-bootstrap-instance-provider = cf_bootstrap_instance.provider:main
+
+[cogniflow.semantic_sources]
+cf-bootstrap-instance = cf_bootstrap_instance:semantic_files