rosetta-build 0.1.0__py3-none-any.whl

rosetta_build/__init__.py

@@ -0,0 +1,3 @@
+from rosetta_build.cli import main
+
+__all__ = ["main"]

rosetta_build/__main__.py

@@ -0,0 +1,4 @@
+from rosetta_build.cli import main
+
+if __name__ == "__main__":
+    main()

rosetta_build/backend.py

@@ -0,0 +1,182 @@
+"""PEP 517 build-backend hooks for rosetta-build."""
+
+from __future__ import annotations
+
+import asyncio
+import shutil
+import tempfile
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from rosetta_build.collect import Collection, CollectionError, collect
+from rosetta_build.execute import BuildError, run_build
+from rosetta_build.language import CompilerFamily
+from rosetta_build.metadata import (
+    MetadataError,
+    ProjectMetadata,
+    load_project_metadata,
+    names_match,
+)
+from rosetta_build.plan import BuildPlan, PlanError, plan_build
+from rosetta_build.target import WheelTarget
+from rosetta_build.wheel import write_dist_info
+
+__all__ = [
+    "BackendError",
+    "build_sdist",
+    "build_wheel",
+    "get_requires_for_build_sdist",
+    "get_requires_for_build_wheel",
+    "prepare_metadata_for_build_wheel",
+]
+
+
+class BackendError(Exception):
+    """Raised when a PEP 517 hook cannot complete."""
+
+
+def get_requires_for_build_wheel(
+    config_settings: dict[str, Any] | None = None,
+) -> list[str]:
+    del config_settings
+    return []
+
+
+def get_requires_for_build_sdist(
+    config_settings: dict[str, Any] | None = None,
+) -> list[str]:
+    del config_settings
+    return []
+
+
+def prepare_metadata_for_build_wheel(
+    metadata_directory: str,
+    config_settings: dict[str, Any] | None = None,
+) -> str:
+    del config_settings
+    try:
+        metadata = _distribution_metadata(Path.cwd())
+        return write_dist_info(metadata, Path(metadata_directory))
+    except (CollectionError, MetadataError, PlanError, BackendError) as exc:
+        raise BackendError(str(exc)) from exc
+
+
+def build_wheel(
+    wheel_directory: str,
+    config_settings: dict[str, Any] | None = None,
+    metadata_directory: str | None = None,
+) -> str:
+    del metadata_directory
+    try:
+        plan = _plan_for_cwd(config_settings)
+        asyncio.run(run_build(plan))
+        target = _primary_wheel_target_name(plan)
+        built = plan.wheel_artifact_by_target[target]
+        return _copy_artifact(built, Path(wheel_directory))
+    except (CollectionError, MetadataError, PlanError, BuildError, BackendError) as exc:
+        raise BackendError(str(exc)) from exc
+
+
+def build_sdist(
+    sdist_directory: str,
+    config_settings: dict[str, Any] | None = None,
+) -> str:
+    try:
+        plan = _plan_for_cwd(config_settings)
+        asyncio.run(run_build(plan))
+        target = _primary_wheel_target_name(plan)
+        built = plan.sdist_artifact_by_target[target]
+        return _copy_artifact(built, Path(sdist_directory))
+    except (CollectionError, MetadataError, PlanError, BuildError, BackendError) as exc:
+        raise BackendError(str(exc)) from exc
+
+
+def _plan_for_cwd(config_settings: dict[str, Any] | None) -> BuildPlan:
+    source_tree = Path.cwd()
+    collection = collect(source_tree)
+    _primary_wheel_target(collection, load_project_metadata(source_tree))
+    build_dir = _build_dir(source_tree, config_settings)
+    family = _family(config_settings)
+    return plan_build(collection, build_dir=build_dir, family=family)
+
+
+def _distribution_metadata(source_tree: Path) -> ProjectMetadata:
+    collection = collect(source_tree)
+    metadata = load_project_metadata(source_tree)
+    target = _primary_wheel_target(collection, metadata)
+    if names_match(target.name, metadata.name):
+        return metadata
+    return metadata.with_name(target.name)
+
+
+def _primary_wheel_target(
+    collection: Collection, metadata: ProjectMetadata
+) -> WheelTarget:
+    wheels = [
+        target
+        for target in collection.targets.values()
+        if isinstance(target, WheelTarget)
+    ]
+    if not wheels:
+        raise BackendError(
+            'PEP 517 backend requires at least one type = "wheel" target'
+        )
+    matching = [target for target in wheels if names_match(target.name, metadata.name)]
+    if len(matching) == 1:
+        return matching[0]
+    if len(wheels) == 1:
+        return wheels[0]
+    names = ", ".join(sorted(target.name for target in wheels))
+    raise BackendError(
+        f"ambiguous wheel targets for distribution {metadata.name!r}: {names}"
+    )
+
+
+def _primary_wheel_target_name(plan: BuildPlan) -> str:
+    if len(plan.wheel_steps) == 1:
+        return plan.wheel_steps[0].target
+    if not plan.wheel_steps:
+        raise BackendError("planned build has no wheel targets")
+    names = ", ".join(step.target for step in plan.wheel_steps)
+    raise BackendError(f"planned build has multiple wheel targets: {names}")
+
+
+def _build_dir(source_tree: Path, config_settings: dict[str, Any] | None) -> Path:
+    configured = _config_value(config_settings, "build-dir", "build_dir")
+    if configured is not None:
+        path = Path(configured)
+        if not path.is_absolute():
+            path = source_tree / path
+        return path
+    return Path(tempfile.mkdtemp(prefix="rosetta-build-"))
+
+
+def _family(config_settings: dict[str, Any] | None) -> CompilerFamily:
+    configured = _config_value(config_settings, "family") or CompilerFamily.GCC.value
+    try:
+        return CompilerFamily(configured)
+    except ValueError as exc:
+        raise BackendError(f"unknown compiler family: {configured!r}") from exc
+
+
+def _config_value(config_settings: Mapping[str, Any] | None, *keys: str) -> str | None:
+    if not config_settings:
+        return None
+    for key in keys:
+        if key not in config_settings:
+            continue
+        value = config_settings[key]
+        if isinstance(value, list):
+            if not value:
+                return None
+            return str(value[-1])
+        return str(value)
+    return None
+
+
+def _copy_artifact(built: Path, destination_dir: Path) -> str:
+    destination_dir.mkdir(parents=True, exist_ok=True)
+    dest = destination_dir / built.name
+    shutil.copy2(built, dest)
+    return dest.name

rosetta_build/cli.py

@@ -0,0 +1,217 @@
+"""Command-line interface for rosetta-build."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import sys
+from pathlib import Path
+
+from rosetta_build.collect import Collection, CollectionError, collect
+from rosetta_build.collect_graphviz import write_collection_dot
+from rosetta_build.execute import BuildError, run_build, run_link
+from rosetta_build.language import CompilerFamily
+from rosetta_build.plan import BuildPlan, PlanError, plan_build
+from rosetta_build.target import (
+    DynamicLibraryTarget,
+    ExecutableTarget,
+    ModuleImplementationTarget,
+    ModuleInterfaceTarget,
+    ModulePartitionTarget,
+    StaticLibraryTarget,
+    Target,
+    WheelTarget,
+)
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    try:
+        raise SystemExit(args.handler(args))
+    except CollectionError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        raise SystemExit(1) from exc
+    except PlanError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        raise SystemExit(1) from exc
+    except BuildError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        if exc.stderr:
+            print(exc.stderr, file=sys.stderr, end="")
+        raise SystemExit(exc.returncode or 1) from exc
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="rosetta-build",
+        description="Experimental multilanguage build tool.",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    collect_parser = subparsers.add_parser(
+        "collect",
+        help=(
+            "Load and validate targets, then build source, usage, link, "
+            "and module graphs."
+        ),
+    )
+    collect_parser.add_argument(
+        "source_tree",
+        type=Path,
+        help="Source tree root containing pyproject.toml.",
+    )
+    collect_parser.add_argument(
+        "--graphviz",
+        type=Path,
+        metavar="OUT",
+        help="Write Graphviz DOT for the collected graphs to OUT.",
+    )
+    collect_parser.set_defaults(handler=_cmd_collect)
+
+    build_parser = subparsers.add_parser(
+        "build",
+        help=(
+            "Compile native/module targets and build wheel/sdist targets "
+            "(GCC/g++ for native for now)."
+        ),
+    )
+    _add_build_args(build_parser)
+    build_parser.set_defaults(handler=_cmd_build)
+
+    link_parser = subparsers.add_parser(
+        "link",
+        help="Link compiled objects into libraries and executables.",
+    )
+    _add_build_args(link_parser)
+    link_parser.set_defaults(handler=_cmd_link)
+
+    install_parser = subparsers.add_parser(
+        "install",
+        help="Install build artifacts (not yet implemented).",
+    )
+    install_parser.set_defaults(handler=_cmd_not_implemented, step_name="install")
+
+    return parser
+
+
+def _add_build_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "source_tree",
+        type=Path,
+        help="Source tree root containing pyproject.toml.",
+    )
+    parser.add_argument(
+        "--build-dir",
+        type=Path,
+        default=None,
+        help="Build output directory (default: <source_tree>/build).",
+    )
+    parser.add_argument(
+        "--family",
+        type=str,
+        default=CompilerFamily.GCC.value,
+        choices=[family.value for family in CompilerFamily],
+        help="Compiler family (default: gcc).",
+    )
+
+
+def _cmd_collect(args: argparse.Namespace) -> int:
+    collection = collect(args.source_tree)
+    _print_collection(collection)
+    if args.graphviz is not None:
+        write_collection_dot(collection, args.graphviz)
+        print(f"wrote graphviz: {args.graphviz}")
+    return 0
+
+
+def _cmd_build(args: argparse.Namespace) -> int:
+    plan = _plan_from_args(args)
+    asyncio.run(run_build(plan))
+    print(f"compiled {len(plan.compile_steps)} translation unit(s)")
+    print(f"built {len(plan.wheel_steps)} wheel/sdist target(s)")
+    for name, path in sorted(plan.wheel_artifact_by_target.items()):
+        print(f"  wheel {name}: {path}")
+    for name, path in sorted(plan.sdist_artifact_by_target.items()):
+        print(f"  sdist {name}: {path}")
+    return 0
+
+
+def _cmd_link(args: argparse.Namespace) -> int:
+    plan = _plan_from_args(args)
+    asyncio.run(run_link(plan))
+    print(f"linked {len(plan.link_steps)} artifact(s)")
+    for name, path in sorted(plan.link_artifact_by_target.items()):
+        print(f"  {name}: {path}")
+    return 0
+
+
+def _plan_from_args(args: argparse.Namespace) -> BuildPlan:
+    collection = collect(args.source_tree)
+    build_dir = args.build_dir
+    if build_dir is None:
+        build_dir = collection.source_tree / "build"
+    return plan_build(
+        collection,
+        build_dir=build_dir,
+        family=CompilerFamily(args.family),
+    )
+
+
+def _cmd_not_implemented(args: argparse.Namespace) -> int:
+    print(f"error: '{args.step_name}' is not implemented yet", file=sys.stderr)
+    return 1
+
+
+def _print_collection(collection: Collection) -> None:
+    print(f"source tree: {collection.source_tree}")
+    print(f"targets: {len(collection.targets)}")
+    for name in sorted(collection.targets):
+        target = collection.targets[name]
+        sources = collection.source_graph.sources_for(name)
+        usage = collection.usage_graph.dependencies_of(name)
+        links = collection.link_graph.dependencies_of(name)
+        module_imports = collection.module_graph.dependencies_of(name)
+        print(f"  {name} ({_target_kind(target)})")
+        print(f"    config: {target.config_path}")
+        print(f"    sources ({len(sources)}):")
+        for source in sorted(sources):
+            print(f"      {source.relative_to(collection.source_tree)}")
+        print(f"    usage ({len(usage)}):")
+        for dep in sorted(usage):
+            print(f"      {dep}")
+        print(f"    dynamic link libraries ({len(links)}):")
+        for lib in sorted(links):
+            print(f"      {lib}")
+        print(f"    module deps ({len(module_imports)}):")
+        for dep in sorted(module_imports):
+            print(f"      {dep}")
+        exports = collection.module_exports.get(name, frozenset())
+        if exports:
+            print(f"    module exports ({len(exports)}):")
+            for exported in sorted(exports):
+                print(f"      {exported}")
+    print("dynamic link order:")
+    for name in collection.link_graph.topological_order(kind="dynamic link"):
+        print(f"  {name}")
+    print("module order:")
+    for name in collection.module_graph.topological_order(kind="module"):
+        print(f"  {name}")
+
+
+def _target_kind(target: Target) -> str:
+    if isinstance(target, ExecutableTarget):
+        return "executable"
+    if isinstance(target, StaticLibraryTarget):
+        return "static_library"
+    if isinstance(target, DynamicLibraryTarget):
+        return "dynamic_library"
+    if isinstance(target, ModuleInterfaceTarget):
+        return "module_interface"
+    if isinstance(target, ModulePartitionTarget):
+        return "module_partition"
+    if isinstance(target, ModuleImplementationTarget):
+        return "module_implementation"
+    if isinstance(target, WheelTarget):
+        return "wheel"
+    return type(target).__name__