rosetta-build 0.1.0__tar.gz

rosetta_build-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Will Bowers (ralian)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rosetta_build-0.1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: rosetta-build
+Version: 0.1.0
+Summary: Flat (non-meta) multilanguage build tool with a Python planner
+Keywords: build,c++,modules,packaging,pep517,rust
+Author: ralian
+Author-email: ralian <wbowers314@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Typing :: Typed
+Requires-Dist: pydantic>=2.13.5
+Requires-Python: >=3.14
+Project-URL: Homepage, https://github.com/ralian/rosetta-build
+Project-URL: Repository, https://github.com/ralian/rosetta-build
+Project-URL: Issues, https://github.com/ralian/rosetta-build/issues
+Description-Content-Type: text/markdown
+
+# rosetta-build: experimental python-based direct multilanguage build tool
+
+The vision:
+- Abstract compiler and language-independent build planner and executor
+- Rosetta will handle build configuration, planning, and build execution
+- Bring Your Own Compiler: As long as you have a compiler in your environment, Rosetta will handle everything else.
+
+The roadmap:
+- Start with a Python API, types, and build tests which implementations should pass.
+- Each compiler/linker/tool will implement an interace Rosetta defines. We will target the big three C++ compilers and rustc first.
+- Support C++ modules early on, shortly after the basic Big 3 implementation. We should encourage modules-first. Strike while the iron is hot.
+- Add some packaging and dependency resolution niceities after. Implement common package spec?
+
+## Development Checks
+
+```
+uv sync --all-groups
+uv run ruff check --fix
+uv run ruff format --preview
+uv run mypy --strict .
+```

rosetta_build-0.1.0/README.md

@@ -0,0 +1,21 @@
+# rosetta-build: experimental python-based direct multilanguage build tool
+
+The vision:
+- Abstract compiler and language-independent build planner and executor
+- Rosetta will handle build configuration, planning, and build execution
+- Bring Your Own Compiler: As long as you have a compiler in your environment, Rosetta will handle everything else.
+
+The roadmap:
+- Start with a Python API, types, and build tests which implementations should pass.
+- Each compiler/linker/tool will implement an interace Rosetta defines. We will target the big three C++ compilers and rustc first.
+- Support C++ modules early on, shortly after the basic Big 3 implementation. We should encourage modules-first. Strike while the iron is hot.
+- Add some packaging and dependency resolution niceities after. Implement common package spec?
+
+## Development Checks
+
+```
+uv sync --all-groups
+uv run ruff check --fix
+uv run ruff format --preview
+uv run mypy --strict .
+```

rosetta_build-0.1.0/pyproject.toml

@@ -0,0 +1,79 @@
+[project]
+name = "rosetta-build"
+version = "0.1.0"
+description = "Flat (non-meta) multilanguage build tool with a Python planner"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+keywords = [
+    "build",
+    "c++",
+    "modules",
+    "packaging",
+    "pep517",
+    "rust",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Build Tools",
+    "Typing :: Typed",
+]
+dependencies = ["pydantic>=2.13.5"]
+
+[[project.authors]]
+name = "ralian"
+email = "wbowers314@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/ralian/rosetta-build"
+Repository = "https://github.com/ralian/rosetta-build"
+Issues = "https://github.com/ralian/rosetta-build/issues"
+
+[project.scripts]
+rosetta-build = "rosetta_build.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.12.5,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "mypy>=2.3.1",
+    "pytest>=9.1.1",
+    "ruff>=0.16.8",
+]
+
+[tool.uv.build-backend]
+module-root = "src"
+module-name = "rosetta_build"
+source-exclude = [
+    "tests/**",
+    "docs/**",
+]
+wheel-exclude = [
+    "tests/**",
+    "docs/**",
+]
+
+[tool.mypy]
+strict = true
+files = [
+    "src",
+    "tests",
+]
+exclude = ["^tests/trees/"]
+
+[tool.ruff]
+target-version = "py314"
+src = [
+    "src",
+    "tests",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

rosetta_build-0.1.0/pyproject.toml.orig

@@ -0,0 +1,76 @@
+[project]
+name = "rosetta-build"
+version = "0.1.0"
+description = "Flat (non-meta) multilanguage build tool with a Python planner"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "ralian", email = "wbowers314@gmail.com" }
+]
+requires-python = ">=3.14"
+keywords = [
+    "build",
+    "c++",
+    "modules",
+    "packaging",
+    "pep517",
+    "rust",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Build Tools",
+    "Typing :: Typed",
+]
+dependencies = [
+    "pydantic>=2.13.5",
+]
+
+[project.urls]
+Homepage = "https://github.com/ralian/rosetta-build"
+Repository = "https://github.com/ralian/rosetta-build"
+Issues = "https://github.com/ralian/rosetta-build/issues"
+
+[project.scripts]
+rosetta-build = "rosetta_build.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.12.5,<0.13.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "mypy>=2.3.1",
+    "pytest>=9.1.1",
+    "ruff>=0.16.8",
+]
+
+[tool.uv.build-backend]
+module-root = "src"
+module-name = "rosetta_build"
+source-exclude = [
+    "tests/**",
+    "docs/**",
+]
+wheel-exclude = [
+    "tests/**",
+    "docs/**",
+]
+
+[tool.mypy]
+strict = true
+files = ["src", "tests"]
+exclude = [
+    "^tests/trees/",
+]
+
+[tool.ruff]
+target-version = "py314"
+src = ["src", "tests"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

rosetta_build-0.1.0/src/rosetta_build/__init__.py

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

rosetta_build-0.1.0/src/rosetta_build/__main__.py

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

rosetta_build-0.1.0/src/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-0.1.0/src/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__