dryv-compiler 0.0.1__py3-none-any.whl

dryv_compiler/__init__.py

@@ -0,0 +1,21 @@
+from .compatibility import AuthorCompatibilityError, validate_author_compatibility
+from .mapping import compile_app, compile_ir
+from .version import (
+    AUTHOR_COMPATIBILITY,
+    COMPILER_VERSION,
+    SUPPORTED_AUTHORING_PROTOCOLS,
+    SUPPORTED_RUNTIME_IR_VERSIONS,
+    __version__,
+)
+
+__all__ = [
+    "AUTHOR_COMPATIBILITY",
+    "COMPILER_VERSION",
+    "SUPPORTED_AUTHORING_PROTOCOLS",
+    "SUPPORTED_RUNTIME_IR_VERSIONS",
+    "AuthorCompatibilityError",
+    "__version__",
+    "compile_app",
+    "compile_ir",
+    "validate_author_compatibility",
+]

dryv_compiler/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

dryv_compiler/cli.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import argparse
+import json
+import signal
+import sys
+from collections.abc import Sequence
+from threading import Thread
+
+from .execution import inspect_python_environment
+from .protocol import (
+    AuthoringServerMessage,
+    CancellationToken,
+    CancelRequest,
+    CompileRequest,
+    ErrorMessage,
+    encode_message,
+    parse_client_message_text,
+    stream_compile,
+)
+from .version import (
+    COMPILER_VERSION,
+    SUPPORTED_AUTHORING_PROTOCOLS,
+    SUPPORTED_RUNTIME_IR_VERSIONS,
+)
+
+
+def _emit(message: AuthoringServerMessage) -> None:
+    sys.stdout.write(encode_message(message))
+    sys.stdout.write("\n")
+    sys.stdout.flush()
+
+
+def _install_signal_cancellation(token: CancellationToken) -> None:
+    def cancel(_signum: int, _frame: object) -> None:
+        token.cancel()
+
+    signal.signal(signal.SIGINT, cancel)
+    signal.signal(signal.SIGTERM, cancel)
+
+
+def _watch_stdin_cancellation(session_id: str, token: CancellationToken) -> None:
+    for raw in sys.stdin:
+        if not raw.strip():
+            continue
+        try:
+            message = parse_client_message_text(raw)
+        except ValueError:
+            continue
+        if isinstance(message, CancelRequest) and message.session_id == session_id:
+            token.cancel()
+            return
+
+
+def _run_request(request: CompileRequest, *, watch_stdin: bool) -> int:
+    token = CancellationToken()
+    _install_signal_cancellation(token)
+    if watch_stdin:
+        Thread(
+            target=_watch_stdin_cancellation,
+            args=(request.session_id, token),
+            daemon=True,
+        ).start()
+    return 0 if stream_compile(request, _emit, cancellation=token) else 1
+
+
+def _stdio() -> int:
+    first = sys.stdin.readline()
+    if not first:
+        sys.stderr.write("dryv-py stdio expected a compile.request JSONL message\n")
+        return 2
+    try:
+        message = parse_client_message_text(first)
+    except ValueError as exc:
+        _emit(ErrorMessage(session_id="unknown", code="PROTOCOL_ERROR", message=str(exc)))
+        return 2
+    if not isinstance(message, CompileRequest):
+        _emit(
+            ErrorMessage(
+                session_id=message.session_id,
+                code="PROTOCOL_ERROR",
+                message="first stdio message must be compile.request",
+            )
+        )
+        return 2
+    return _run_request(message, watch_stdin=True)
+
+
+def _compile(
+    *,
+    entrypoint: str,
+    session_id: str,
+    batch_size: int,
+    protocol: str,
+    runtime_ir: str,
+) -> int:
+    request = CompileRequest(
+        session_id=session_id,
+        entrypoint=entrypoint,
+        protocol_versions=(protocol,),
+        runtime_ir_versions=(runtime_ir,),
+        batch_size=batch_size,
+    )
+    return _run_request(request, watch_stdin=False)
+
+
+def _doctor(entrypoint: str) -> int:
+    report = inspect_python_environment(entrypoint)
+    value: dict[str, object] = {
+        "status": report.status.value,
+        "pythonExecutable": report.python_executable,
+        "pythonVersion": report.python_version,
+        "projectRoot": report.project_root,
+        "entrypoint": report.entrypoint,
+        "virtualEnvironment": report.virtual_environment,
+        "authorVersion": report.author_version,
+    }
+    if report.message is not None:
+        value["message"] = report.message
+    sys.stdout.write(json.dumps(value, sort_keys=True, separators=(",", ":")))
+    sys.stdout.write("\n")
+    return 0 if report.status.value == "READY" else 1
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="dryv-py")
+    parser.add_argument("--version", action="version", version=COMPILER_VERSION)
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    compile_parser = commands.add_parser("compile", help="compile one Python authoring entrypoint")
+    compile_parser.add_argument("entrypoint")
+    compile_parser.add_argument("--session-id", default="standalone")
+    compile_parser.add_argument("--batch-size", type=int, default=64)
+    compile_parser.add_argument("--protocol", default=SUPPORTED_AUTHORING_PROTOCOLS[0])
+    compile_parser.add_argument("--runtime-ir", default=SUPPORTED_RUNTIME_IR_VERSIONS[0])
+
+    commands.add_parser("stdio", help="serve one machine-readable JSONL compile session on stdio")
+    doctor_parser = commands.add_parser("doctor", help="inspect the Python authoring environment")
+    doctor_parser.add_argument("entrypoint")
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    command = str(args.command)
+    if command == "compile":
+        return _compile(
+            entrypoint=str(args.entrypoint),
+            session_id=str(args.session_id),
+            batch_size=int(args.batch_size),
+            protocol=str(args.protocol),
+            runtime_ir=str(args.runtime_ir),
+        )
+    if command == "stdio":
+        return _stdio()
+    if command == "doctor":
+        return _doctor(str(args.entrypoint))
+    parser.error(f"unsupported command: {command}")

dryv_compiler/compatibility.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from dryv_author import AUTHOR_REPRESENTATION_VERSION
+from dryv_author import __version__ as author_version
+from packaging.specifiers import SpecifierSet
+from packaging.version import InvalidVersion, Version
+
+from .version import AUTHOR_COMPATIBILITY, AUTHOR_REPRESENTATION
+
+
+class AuthorCompatibilityError(RuntimeError):
+    """Raised when an author SDK cannot be consumed by this compiler."""
+
+
+@dataclass(frozen=True, slots=True)
+class AuthorCompatibility:
+    author_version: str
+    supported_versions: str
+    representation: str
+
+
+def current_author_compatibility() -> AuthorCompatibility:
+    return AuthorCompatibility(
+        author_version=author_version,
+        supported_versions=AUTHOR_COMPATIBILITY,
+        representation=AUTHOR_REPRESENTATION_VERSION,
+    )
+
+
+def validate_author_details(author_version_value: str, representation: str) -> AuthorCompatibility:
+    compatibility = AuthorCompatibility(
+        author_version=author_version_value,
+        supported_versions=AUTHOR_COMPATIBILITY,
+        representation=representation,
+    )
+    try:
+        parsed = Version(compatibility.author_version)
+    except InvalidVersion as exc:
+        raise AuthorCompatibilityError(
+            f"installed dryv-author version {compatibility.author_version!r} is invalid"
+        ) from exc
+
+    if parsed not in SpecifierSet(compatibility.supported_versions):
+        raise AuthorCompatibilityError(
+            "installed dryv-author version "
+            f"{compatibility.author_version!r} is incompatible with compiler requirement "
+            f"{compatibility.supported_versions!r}"
+        )
+    if compatibility.representation != AUTHOR_REPRESENTATION:
+        raise AuthorCompatibilityError(
+            "installed dryv-author compiler-facing representation "
+            f"{compatibility.representation!r} is incompatible with {AUTHOR_REPRESENTATION!r}"
+        )
+    return compatibility
+
+
+def validate_author_compatibility() -> AuthorCompatibility:
+    compatibility = current_author_compatibility()
+    return validate_author_details(
+        compatibility.author_version,
+        compatibility.representation,
+    )

dryv_compiler/execution/__init__.py

@@ -0,0 +1,23 @@
+from .entrypoint import AuthorEntrypointError, LoadedAuthor, load_author_entrypoint
+from .environment import EnvironmentStatus, PythonEnvironmentReport, inspect_python_environment
+from .project import (
+    CapturedAuthor,
+    ProjectPythonError,
+    capture_author_entrypoint,
+    discover_project_python,
+    inspect_project_python,
+)
+
+__all__ = [
+    "AuthorEntrypointError",
+    "CapturedAuthor",
+    "EnvironmentStatus",
+    "LoadedAuthor",
+    "ProjectPythonError",
+    "PythonEnvironmentReport",
+    "capture_author_entrypoint",
+    "discover_project_python",
+    "inspect_project_python",
+    "inspect_python_environment",
+    "load_author_entrypoint",
+]

dryv_compiler/execution/bootstrap.py

@@ -0,0 +1,106 @@
+"""Project-Python bootstrap used by the reusable Dryv Python compiler.
+
+This file intentionally depends only on the Python standard library and the
+project-installed ``dryv_author`` package. It is executed by the project's
+Python interpreter, not imported as compiler runtime code.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import runpy
+import sys
+from dataclasses import fields, is_dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from dryv_author import AUTHOR_REPRESENTATION_VERSION, AppDeclaration
+from dryv_author import __version__ as author_version
+from dryv_author.state import DeclarationIdentity
+
+
+def _type_name(value: object) -> str:
+    kind = type(value)
+    return f"{kind.__module__}:{kind.__qualname__}"
+
+
+_IDENTITIES: dict[int, int] = {}
+
+
+def _encode(value: Any) -> Any:
+    if isinstance(value, DeclarationIdentity):
+        number = _IDENTITIES.setdefault(id(value), len(_IDENTITIES) + 1)
+        return {"$identity": number, "$label": value.label}
+    if is_dataclass(value) and not isinstance(value, type):
+        return {
+            "$type": _type_name(value),
+            "$fields": {field.name: _encode(getattr(value, field.name)) for field in fields(value)},
+        }
+    if isinstance(value, Enum):
+        return {"$enum": _type_name(value), "$value": _encode(value.value)}
+    if isinstance(value, tuple):
+        return {"$tuple": [_encode(item) for item in value]}
+    if isinstance(value, list):
+        return [_encode(item) for item in value]
+    if isinstance(value, dict):
+        return {
+            "$dict": [
+                [_encode(key), _encode(value[key])]
+                for key in sorted(value, key=lambda item: str(item))
+            ]
+        }
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    raise TypeError(
+        f"unsupported author snapshot value {type(value).__module__}.{type(value).__qualname__}"
+    )
+
+
+def _load_author(entrypoint: Path) -> AppDeclaration:
+    entry_root = str(entrypoint.parent)
+    if entry_root not in sys.path:
+        sys.path.insert(0, entry_root)
+    with contextlib.redirect_stdout(sys.stderr):
+        namespace = runpy.run_path(str(entrypoint), run_name="__dryv_authoring__")
+    found: dict[int, AppDeclaration] = {}
+    for name in sorted(namespace):
+        value = namespace[name]
+        if isinstance(value, AppDeclaration):
+            found[id(value)] = value
+    if not found:
+        raise RuntimeError(
+            "authoring entrypoint did not expose a dryv_author app (dryv.app(...)); "
+            "assign the result of dryv(...) to a module-level name"
+        )
+    if len(found) > 1:
+        raise RuntimeError("authoring entrypoint exposed multiple independent Dryv apps")
+    return next(iter(found.values()))
+
+
+def main() -> int:
+    if len(sys.argv) != 2:
+        sys.stderr.write("usage: bootstrap.py <authoring-entrypoint>\n")
+        return 2
+    entrypoint = Path(sys.argv[1]).expanduser().resolve()
+    if not entrypoint.is_file():
+        sys.stderr.write(f"authoring entrypoint does not exist: {entrypoint}\n")
+        return 2
+    try:
+        author = _load_author(entrypoint)
+        payload = {
+            "authorVersion": author_version,
+            "authorRepresentation": AUTHOR_REPRESENTATION_VERSION,
+            "state": _encode(author.snapshot()),
+        }
+        sys.stdout.write(json.dumps(payload, sort_keys=True, separators=(",", ":")))
+        sys.stdout.write("\n")
+        return 0
+    except Exception as exc:
+        sys.stderr.write(f"{type(exc).__name__}: {exc}\n")
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

dryv_compiler/execution/entrypoint.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import runpy
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+
+from dryv_author import AppDeclaration
+
+
+class AuthorEntrypointError(RuntimeError):
+    """Raised when a Python authoring entrypoint cannot yield one declaration graph."""
+
+
+@dataclass(frozen=True, slots=True)
+class LoadedAuthor:
+    author: AppDeclaration
+    entrypoint: str
+    exported_names: tuple[str, ...]
+
+
+def load_author_entrypoint(entrypoint: str) -> LoadedAuthor:
+    path = Path(entrypoint).expanduser().resolve()
+    if not path.is_file():
+        raise AuthorEntrypointError(f"authoring entrypoint does not exist: {path}")
+    if path.suffix.lower() != ".py":
+        raise AuthorEntrypointError("Python authoring entrypoint must use the .py extension")
+
+    entry_root = str(path.parent)
+    added_to_path = entry_root not in sys.path
+    if added_to_path:
+        sys.path.insert(0, entry_root)
+    try:
+        namespace = runpy.run_path(str(path), run_name="__dryv_authoring__")
+    finally:
+        if added_to_path:
+            sys.path.remove(entry_root)
+    found: dict[int, tuple[AppDeclaration, list[str]]] = {}
+    for name in sorted(namespace):
+        value = namespace[name]
+        if not isinstance(value, AppDeclaration):
+            continue
+        identity = id(value)
+        existing = found.get(identity)
+        if existing is None:
+            found[identity] = (value, [name])
+        else:
+            existing[1].append(name)
+
+    if not found:
+        raise AuthorEntrypointError(
+            "authoring entrypoint did not expose a dryv_author.AppDeclaration instance; "
+            "assign the result of dryv(...) to a module-level name"
+        )
+    if len(found) > 1:
+        exports = sorted(name for _, names in found.values() for name in names)
+        raise AuthorEntrypointError(
+            "authoring entrypoint exposed multiple independent AppDeclaration graphs: "
+            + ", ".join(exports)
+        )
+
+    author, names = next(iter(found.values()))
+    return LoadedAuthor(author=author, entrypoint=str(path), exported_names=tuple(sorted(names)))

dryv_compiler/execution/environment.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+from pathlib import Path
+
+from dryv_compiler.compatibility import AuthorCompatibilityError, validate_author_details
+
+from .project import ProjectPythonError, inspect_project_python
+
+
+class EnvironmentStatus(StrEnum):
+    READY = "READY"
+    RUNTIME_MISSING = "RUNTIME_MISSING"
+    RUNTIME_INCOMPATIBLE = "RUNTIME_INCOMPATIBLE"
+    SDK_MISSING = "SDK_MISSING"
+    SDK_INCOMPATIBLE = "SDK_INCOMPATIBLE"
+    ENTRYPOINT_MISSING = "ENTRYPOINT_MISSING"
+
+
+@dataclass(frozen=True, slots=True)
+class PythonEnvironmentReport:
+    status: EnvironmentStatus
+    python_executable: str
+    python_version: str
+    project_root: str
+    entrypoint: str
+    virtual_environment: str | None
+    author_version: str
+    author_representation: str
+    message: str | None = None
+
+
+def _empty_report(
+    status: EnvironmentStatus,
+    entrypoint: Path,
+    *,
+    message: str,
+) -> PythonEnvironmentReport:
+    return PythonEnvironmentReport(
+        status=status,
+        python_executable="",
+        python_version="",
+        project_root=str(entrypoint.parent),
+        entrypoint=str(entrypoint),
+        virtual_environment=None,
+        author_version="",
+        author_representation="",
+        message=message,
+    )
+
+
+def inspect_python_environment(entrypoint: str) -> PythonEnvironmentReport:
+    resolved = Path(entrypoint).expanduser().resolve()
+    if not resolved.is_file():
+        return _empty_report(
+            EnvironmentStatus.ENTRYPOINT_MISSING,
+            resolved,
+            message=f"authoring entrypoint does not exist: {resolved}",
+        )
+
+    try:
+        facts = inspect_project_python(str(resolved))
+    except ProjectPythonError as exc:
+        error_message = str(exc)
+        status = (
+            EnvironmentStatus.SDK_MISSING
+            if "dryv_author" in error_message or "dryv-author" in error_message
+            else EnvironmentStatus.RUNTIME_MISSING
+        )
+        return _empty_report(status, resolved, message=error_message)
+
+    python_version = str(facts["pythonVersion"] or "")
+    try:
+        major, minor, *_ = (int(part) for part in python_version.split("."))
+    except (TypeError, ValueError):
+        return _empty_report(
+            EnvironmentStatus.RUNTIME_INCOMPATIBLE,
+            resolved,
+            message=f"project Python reported invalid version {python_version!r}",
+        )
+    if (major, minor) < (3, 11):
+        return PythonEnvironmentReport(
+            status=EnvironmentStatus.RUNTIME_INCOMPATIBLE,
+            python_executable=str(facts["pythonExecutable"] or ""),
+            python_version=python_version,
+            project_root=str(facts["projectRoot"] or resolved.parent),
+            entrypoint=str(resolved),
+            virtual_environment=(
+                str(facts["virtualEnvironment"])
+                if facts["virtualEnvironment"] is not None
+                else None
+            ),
+            author_version=str(facts["authorVersion"] or ""),
+            author_representation=str(facts["authorRepresentation"] or ""),
+            message="dryv-py requires Python 3.11 or newer",
+        )
+
+    author_version = str(facts["authorVersion"] or "")
+    representation = str(facts["authorRepresentation"] or "")
+    compatibility_message: str | None
+    try:
+        validate_author_details(author_version, representation)
+    except AuthorCompatibilityError as exc:
+        status = EnvironmentStatus.SDK_INCOMPATIBLE
+        compatibility_message = str(exc)
+    else:
+        status = EnvironmentStatus.READY
+        compatibility_message = None
+
+    return PythonEnvironmentReport(
+        status=status,
+        python_executable=str(facts["pythonExecutable"] or ""),
+        python_version=python_version,
+        project_root=str(facts["projectRoot"] or resolved.parent),
+        entrypoint=str(resolved),
+        virtual_environment=(
+            str(facts["virtualEnvironment"]) if facts["virtualEnvironment"] is not None else None
+        ),
+        author_version=author_version,
+        author_representation=representation,
+        message=compatibility_message,
+    )