vest-build-dotnet 0.0.1__tar.gz

vest_build_dotnet-0.0.1/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.3
+Name: vest-build-dotnet
+Version: 0.0.1
+Summary: Vest build support for .NET projects
+Keywords: vest,build,build-system,dotnet,.net,csharp,native-aot,ilc,msbuild,compilation,packaging
+Author: ascpixi
+Author-email: ascpixi <ascpixi@proton.me>
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: C#
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Typing :: Typed
+Requires-Dist: packaging>=26.0
+Requires-Dist: vest-build>=0.0.2
+Requires-Python: >=3.11
+Project-URL: Repository, https://github.com/ascpixi/vest-dotnet
+Description-Content-Type: text/markdown
+
+# Vest support for .NET
+[![image](https://img.shields.io/pypi/v/vest-build-dotnet.svg)](https://pypi.python.org/pypi/vest-build-dotnet)
+[![image](https://img.shields.io/pypi/l/vest-build-dotnet.svg)](https://github.com/ascpixi/vest-dotnet/blob/master/LICENSE)
+[![image](https://img.shields.io/pypi/pyversions/vest-build-dotnet.svg)](https://pypi.python.org/pypi/vest-build-dotnet)
+[![Actions status](https://github.com/ascpixi/vest-dotnet/workflows/CI/badge.svg)](https://github.com/ascpixi/vest-dotnet/actions)
+
+.NET build support for [Vest](https://pypi.org/project/vest-build/), a Python-based build
+system for bespoke use.
+
+## Requirements
+The project assumes that the following dependencies are installed:
+
+- The [.NET SDK](https://dotnet.microsoft.com/download), with `dotnet` on `PATH`.
+- `csc`. You can install this via `dotnet tool install csc`.
+- `ilc` for Native AOT compilation. You can install this via `dotnet tool install ilc`.
+
+## Examples
+
+### Building or publishing an existing project
+
+```python
+from vest import *
+from vest.dotnet import dotnet_publish
+
+component(name = "my-service")
+
+@task
+def publish():
+    artifacts = dotnet_publish(
+        configuration = "Release",
+        rid = "linux-x64"
+    )
+
+    return artifacts.publish
+```
+
+### Native AOT compilation
+
+`ilc_compile` turns an IL assembly into a native object file via `dotnet ilc`, which can then
+be fed into your own linker invocation:
+
+```python
+from vest.dotnet import ilc_compile
+
+@task
+def aot():
+    asm = dotnet_build(
+        configuration = dotnet_configuration(),
+        rid = rid(),
+        properties = {
+            "Arch": "x64"
+        }
+    )
+
+    ilc_compile(
+        input = asm.build,
+        output = f"{artifact_dir()}/obj/my-object.o",
+        target_arch = "x64",
+        stdlib_assembly = "Azerou.CoreLib",
+        nativelib = True
+    )
+```

vest_build_dotnet-0.0.1/README.md

@@ -0,0 +1,62 @@
+# Vest support for .NET
+[![image](https://img.shields.io/pypi/v/vest-build-dotnet.svg)](https://pypi.python.org/pypi/vest-build-dotnet)
+[![image](https://img.shields.io/pypi/l/vest-build-dotnet.svg)](https://github.com/ascpixi/vest-dotnet/blob/master/LICENSE)
+[![image](https://img.shields.io/pypi/pyversions/vest-build-dotnet.svg)](https://pypi.python.org/pypi/vest-build-dotnet)
+[![Actions status](https://github.com/ascpixi/vest-dotnet/workflows/CI/badge.svg)](https://github.com/ascpixi/vest-dotnet/actions)
+
+.NET build support for [Vest](https://pypi.org/project/vest-build/), a Python-based build
+system for bespoke use.
+
+## Requirements
+The project assumes that the following dependencies are installed:
+
+- The [.NET SDK](https://dotnet.microsoft.com/download), with `dotnet` on `PATH`.
+- `csc`. You can install this via `dotnet tool install csc`.
+- `ilc` for Native AOT compilation. You can install this via `dotnet tool install ilc`.
+
+## Examples
+
+### Building or publishing an existing project
+
+```python
+from vest import *
+from vest.dotnet import dotnet_publish
+
+component(name = "my-service")
+
+@task
+def publish():
+    artifacts = dotnet_publish(
+        configuration = "Release",
+        rid = "linux-x64"
+    )
+
+    return artifacts.publish
+```
+
+### Native AOT compilation
+
+`ilc_compile` turns an IL assembly into a native object file via `dotnet ilc`, which can then
+be fed into your own linker invocation:
+
+```python
+from vest.dotnet import ilc_compile
+
+@task
+def aot():
+    asm = dotnet_build(
+        configuration = dotnet_configuration(),
+        rid = rid(),
+        properties = {
+            "Arch": "x64"
+        }
+    )
+
+    ilc_compile(
+        input = asm.build,
+        output = f"{artifact_dir()}/obj/my-object.o",
+        target_arch = "x64",
+        stdlib_assembly = "Azerou.CoreLib",
+        nativelib = True
+    )
+```

vest_build_dotnet-0.0.1/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "vest-build-dotnet"
+version = "0.0.1"
+description = "Vest build support for .NET projects"
+authors = [ { name = "ascpixi", email = "ascpixi@proton.me" } ]
+readme = "README.md"
+requires-python = ">=3.11"
+
+keywords = ["vest", "build",  "build-system", "dotnet", ".net", "csharp", "native-aot", "ilc", "msbuild", "compilation", "packaging"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: C#",
+    "Topic :: Software Development :: Build Tools",
+    "Topic :: Software Development :: Compilers",
+    "Typing :: Typed",
+]
+
+dependencies = [
+    "packaging>=26.0",
+    "vest-build>=0.0.2",
+]
+
+[project.urls]
+Repository = "https://github.com/ascpixi/vest-dotnet"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "vest.dotnet"
+namespace = true

vest_build_dotnet-0.0.1/src/vest/dotnet/__init__.py

@@ -0,0 +1,10 @@
+from .sdk import (
+    dotnet_version,
+    dotnet_sdk_path,
+    dotnet_publish,
+    dotnet_build
+)
+
+from .aot import (
+    ilc_compile
+)

vest_build_dotnet-0.0.1/src/vest/dotnet/aot.py

@@ -0,0 +1,74 @@
+from typing import Literal
+
+from vest.common.collections import maybe
+from vest.spec.core import run
+
+def ilc_compile(
+    *,
+    input: str,
+    output: str,
+    references: list[str] = [],
+    target_arch: str,
+    target_os: str = "linux",
+    stdlib_assembly: str | None = None,
+    method_body_fold = False,
+    optimization: Literal["disable", "enable", "favor_size", "favor_time"] = "disable",
+    emit_debug_info = True,
+    codegen_options: list[str] = [],
+    pre_init_statics = True,
+    generate_reflection_data = False,
+    direct_pinvoke: list[str] = [],
+    nativelib = False,
+    disable_il_scanner = False
+):
+    """
+    Compiles an IL assembly into a native object file via `dotnet ilc`.
+
+    @input: The IL assembly to compile.
+    @output: The path to write the compiled object file to.
+    @references: The assemblies that `@input` references.
+    @target_arch: Specifies the architecture to compile for, e.g. `x64` or `arm64`.
+    @target_os: Specifies the ABI and binary format to compile for, e.g. `linux` or `windows`.
+    @stdlib_assembly: The name of the assembly to consider the standard library.
+    @method_body_fold: If `"true`", identical method bodies will be merged (folded).
+    @optimization: Controls program optimization.
+    @emit_debug_info: If `"true"`, debug information will be included in the object file.
+    @codegen_options: Code generation options in the form of `<key>=<value>`. See https://github.com/dotnet/runtime/blob/main/src/coreclr/jit/jitconfigvalues.h#L32 for details.
+    @pre_init_statics: If `"true"`, static fields will be evaluated at compile-time (if possible).
+    @generate_reflection_data: If `"true"`, reflection data will be included with the object file.
+    @direct_pinvoke: A list of libraries to call the functions of directly, without a P/Invoke stub/wrapper. 
+    @nativelib: If `"true"`, the IL should be compiled as a static or shared library.
+    """
+
+    args = [
+        "ilc",
+        input,
+        f"-o:{output}",
+        *[f"-r:{x}" for x in references],
+        f"--targetos:{target_os}", # This option only chooses the ABI and binary format - for 'linux', the pair is System V and ELF.
+        f"--targetarch:{target_arch}",
+        *maybe("--debug", emit_debug_info == "true"),
+        *maybe(f"--systemmodule:{stdlib_assembly}", stdlib_assembly is not None),
+        *maybe("--preinitstatics", pre_init_statics == "true"),
+        *maybe("--methodbodyfolding", method_body_fold == "true"),
+        *maybe("--nativelib", nativelib == "true"),
+        *maybe("--noscan", disable_il_scanner == "true"),
+        *[f"--directpinvoke:{x}" for x in direct_pinvoke],
+        f"--reflectiondata:{'all' if generate_reflection_data == 'true' else 'none'}",
+        "--verbose",
+        "--noscan"
+    ]
+
+    if optimization != "disable":
+        match optimization:
+            case "enable":
+                args.append("--optimize")
+            case "favor_size":
+                args.append("--optimize-space")
+            case "favor_time":
+                args.append("--optimize-time")
+
+    for opt in codegen_options:
+        args.extend(["--codegenopt", opt])
+
+    run("dotnet", args)

vest_build_dotnet-0.0.1/src/vest/dotnet/sdk.py

@@ -0,0 +1,236 @@
+# This file defines .NET-related functions used within the component-based build system.
+
+from dataclasses import dataclass
+import json
+import os
+import re
+import subprocess
+from typing import Literal, Optional
+from packaging import version
+
+from vest.common.collections import maybe, single
+from vest.spec.types import Component
+from vest.spec.core import host, run, artifact_dir
+
+DotnetVerbosity = Literal["quiet", "minimal", "normal", "detailed", "diagnostic"]
+
+cached_version: Optional[str] = None
+cached_sdk_path: Optional[str] = None
+
+def dotnet_version() -> str:
+    """Gets the short version string of the current .NET SDK (e.g. 8.0)."""
+
+    global cached_version
+    if cached_version is not None:
+        return cached_version
+    
+    full = subprocess.check_output("dotnet --version".split()).decode()
+    ver = full[:full.rfind(".")]
+
+    cached_version = ver
+    return ver
+
+def dotnet_sdk_path() -> str:
+    "Gets the full path to the latest .NET SDK installed on the host system."
+
+    global cached_sdk_path
+    if cached_sdk_path is not None:
+        return cached_sdk_path
+    
+    sdks_raw = subprocess.check_output(["dotnet", "--list-sdks"]).decode()
+
+    # sdks[i][0]: version, sdks[i][1]: root path (pointing where the version dir is located, not to the dir itself)
+    sdks = [(x.group(1), x.group(2)) for x in re.finditer(r"(.+) \[(.+)\]", sdks_raw)]
+    latest_sdk = max(sdks, key = lambda x: version.parse(x[0]))
+
+    path = os.path.join(latest_sdk[1], latest_sdk[0])
+
+    cached_sdk_path = path
+    return path
+
+def _dotnet(
+    action: Literal["build", "publish"],
+    rid: str | None,
+    configuration: str,
+    *,
+    verbosity: DotnetVerbosity = "quiet",
+    properties: dict[str, str] = {}
+):
+    final_props: list[str] = [
+        "-p:VestBuild=true",
+        f"-p:Repo={host().repo_dir}",
+        f"--artifacts-path", artifact_dir()
+    ]
+
+    for (k, v) in host().parameters:
+        if not k.startswith("--"):
+            continue # avoid exposing short-form parameters
+
+        # We need to convert the key into PascalCase, as all MSBuild properties are, by convention, pascal cased.
+        k = re.sub(r"([a-z])([A-Z])", r"\1 \2", k) # camelCase
+        k = re.sub(r"[-_]+", " ", k) # kebab-case and snake_case
+        k = "".join(word.capitalize() for word in k.split())
+
+        final_props.append(f"-p:{k}={v}")
+
+    for (k, v) in properties.items():
+        final_props.append(f"-p:{k}={v}")
+
+    run("dotnet", [
+        action,
+        "-c", configuration,
+        *(["-r", rid] if rid else []),
+        "-v", verbosity,
+        "-tl:off",
+        "--nologo",
+        *final_props
+    ])
+
+    process = subprocess.run(
+        [
+            "dotnet",
+            "build",
+            "-c", configuration,
+            *(["-r", rid] if rid else []),
+            *final_props,
+            "--getTargetResult:" + ",".join([
+                "BuiltProjectOutputGroup", # we always want `build` artifacts
+                "ResolveAssemblyReferences",
+                *maybe("PublishItemsOutputGroup", action == "publish") # `publish` artifacts only available in `publish` builds
+            ])
+        ],
+        capture_output = True,
+        text = True,
+        check = True
+    )
+
+    raw = json.loads(process.stdout)
+    assert type(raw) is dict, f".NET's --getTargetResult output was not a dictionary ({raw})"
+    return raw
+
+def _find_key_artifact(artifacts: dict, group_name: str):
+    items = artifacts["TargetResults"][group_name]["Items"]
+    assert type(items) is list, f"TargetResults.{group_name}.Items was not an array; it's a {type(items)} instead ({items})"
+
+    for item in items:
+        if "IsKeyOutput" in item and item["IsKeyOutput"]:
+            p = item["FullPath"]
+            assert type(p) is str
+            return p
+    
+    # If there's nothing marked as IsKeyOutput, just use the first one.
+    p = items[0]["FullPath"]
+    assert type(p) is str
+    return p
+
+def _extract_all_artifacts(artifacts: dict):
+    results = artifacts["TargetResults"]
+    assert type(results) is dict, f"TargetResults was not a dict; it's a {type(results)} instead ({results})"
+
+    paths: list[str] = []
+
+    for value in results.values():
+        assert type(value) is dict, f"An element of TargetResults was not a dict; it's a {type(value)} instead ({value})"
+
+        items = value["Items"]
+        assert type(items) is list, f"TargetResults[?].Items was not a list; it's a {type(items)} instead ({items})"
+
+        for item in items:
+            p = item["FullPath"]
+            assert type(p) is str
+            paths.append(p)
+
+    return paths
+
+def _extract_references(artifacts: dict) -> list[str]:
+    items = artifacts["TargetResults"]["ResolveAssemblyReferences"]["Items"]
+    assert type(items) is list, f"TargetResults.ResolveAssemblyReferences.Items was not an array; it's a {type(items)} instead ({items})"
+    return [x["FullPath"] for x in items]
+
+@dataclass
+class DotnetPublishArtifacts:
+    publish: str
+    "The path to the main, key publish artifact. For example, for AOT compilation, this would be the native executable."
+
+    build: str
+    "The path to the main, key build artifact. This is usually a binary that hasn't been processed by the publish target."
+
+    all: list[str]
+    "Full paths to all other artifacts. This also includes non-key artifacts, like debug information."
+
+    references: list[str]
+    "A list of full paths to assemblies that have been referenced by the published project."
+
+def dotnet_publish(
+    configuration: str,
+    rid: str | None = None,
+    *,
+    verbosity: DotnetVerbosity = "quiet",
+    properties: dict[str, str] = {}
+) -> DotnetPublishArtifacts:
+    """
+    Publishes a .NET project. All resulting files will be placed in the root of the
+    calling component's artifact directory - that is, `/artifacts/<component name>/...`
+    if `artifacts_path` is set to `None`.
+    
+    @artifacts_path: The directory to place all artifacts (`bin` and `obj`) in.
+    @verbosity: The verbosity level.
+    @configuration: The configuration to publish for. By default, `host().config` is used.
+    @rid: The runtime identifier, e.g. `linux-x64`.
+    @properties: The properties to forward to the build system. Aggregates into `-p:(key)=(value)`.
+    """
+    artifacts = _dotnet("publish",
+        verbosity = verbosity,
+        configuration = configuration,
+        rid = rid,
+        properties = properties
+    )
+
+    return DotnetPublishArtifacts(
+        publish = _find_key_artifact(artifacts, "PublishItemsOutputGroup"),
+        build = _find_key_artifact(artifacts, "BuiltProjectOutputGroup"),
+        all = _extract_all_artifacts(artifacts),
+        references = _extract_references(artifacts)
+    )
+
+@dataclass
+class DotnetBuildArtifacts:
+    build: str
+    "The path to the main, key build artifact."
+
+    all: list[str]
+    "Full paths to all other artifacts. This also includes non-key artifacts, like debug information."
+
+    references: list[str]
+    "A list of full paths to assemblies that have been referenced by the built project."
+
+def dotnet_build(
+    configuration: str,
+    rid: str | None = None,
+    *,
+    verbosity: DotnetVerbosity = "quiet",
+    properties: dict[str, str] = {}
+) -> DotnetBuildArtifacts:
+    """
+    Builds a .NET project. All resulting files will be placed in the root of the
+    calling component's artifact directory - that is, `/artifacts/<component name>/...`
+    if `artifacts_path` is set to `None`.
+    
+    @artifacts_path: The directory to place all artifacts (`bin` and `obj`) in.
+    @verbosity: The verbosity level.
+    @configuration: The configuration to publish for. By default, `host().config` is used.
+    @rid: The runtime identifier, e.g. `linux-x64`.
+    @properties: The properties to forward to the build system. Aggregates into `-p:(key)=(value)`.
+    """
+    artifacts = _dotnet("build",
+        verbosity = verbosity,
+        configuration = configuration,
+        rid = rid,
+        properties = properties
+    )
+
+    return DotnetBuildArtifacts(
+        build = _find_key_artifact(artifacts, "BuiltProjectOutputGroup"),
+        all = _extract_all_artifacts(artifacts),
+        references = _extract_references(artifacts)
+    )