pants-backend-platforms 0.1.0__tar.gz

pants_backend_platforms-0.1.0/LICENSE-MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Tom Solberg
+
+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.

pants_backend_platforms-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.1
+Name: pants_backend_platforms
+Version: 0.1.0
+Summary: Multi-platform builds for Pants backends: platform targets and a contract for building dependencies per platform.
+Keywords: pantsbuild,pants,backend,cross-compilation,platforms
+Author-Email: Tom Solberg <me@sbg.dev>
+License: MIT License
+         
+         Copyright (c) 2022 Tom Solberg
+         
+         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.
+         
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Build Tools
+Project-URL: Repository, https://github.com/tgolsson/pants-backends
+Project-URL: Code, https://github.com/tgolsson/pants-backends/tree/main/pants-plugins/platforms
+Project-URL: Changelog, https://github.com/tgolsson/pants-backends/tree/main/pants-plugins/platforms/CHANGELOG.md
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# pants-backend-platforms
+
+A [Pants](https://www.pantsbuild.org) backend for building targets for more than one platform.
+It has no build rules of its own: language backends (such as pants-backend-cmake) use it to
+know which platforms to build and how to ask another backend for a dependency built for the
+same platform. The C and C++ toolchain for each platform is in [pants-backend-cc](../cc).
+
+This release targets Pants **2.32.x**. Install it with `pants-backend-platforms==0.1.0` in
+`[GLOBAL].plugins` in `pants.toml`, and enable `pants_backend_platforms` in
+`[GLOBAL].backend_packages`.
+
+**Status: alpha.**
+
+## Targets
+
+```python
+platform(name="linux-x86_64", os="linux", arch="x86_64")
+platform(name="windows-x86_64", os="windows", arch="x86_64")
+```
+
+- `platform`: `os` (`linux`, `windows`, `macos`) and `arch` (`x86_64`, `aarch64`). Everything
+  refers to a platform by its target name, so names are unique.
+- The host is the `platform` matching the machine Pants runs on. When several match, choose
+  with `[platforms].host`; when none does, there is an implicit `<os>-<arch>` platform.
+
+## Choosing what to build
+
+A target of a backend that supports platforms has a `platforms` field: the platforms it can be
+built for, the host alone when unset.
+
+```python
+cmake_target(name="app", project=":project", platforms=["linux-x86_64", "windows-x86_64"])
+```
+
+`pants package` builds the platforms in that list that are the host or in
+`[platforms].enabled`. The host's output keeps its usual path in `dist/`, and every other
+platform's goes under `dist/<platform>/`:
+
+```
+pants --platforms-enabled="['windows-x86_64']" package ::
+```
+
+A target built for a platform has its dependencies built for the same platform, enabled or not.
+A dependency whose `platforms` does not list it is an error naming both targets.
+
+Enable extra platforms where the packages are published rather than in `pants.toml`: whatever
+packages a target, such as a test's `runtime_package_dependencies` or an `archive`, gets every
+enabled platform too.
+
+## For backend authors
+
+- Make the field set a `PlatformBuildFieldSet` member, which brings the `platforms` field, and
+  register `UnionRule(PlatformBuildFieldSet, MyFieldSet)`. Its rule takes the field set and a
+  `TargetPlatform` and returns a `PlatformBuild`: the files at the paths `pants package` writes
+  them to for the host.
+- `build_platform_dependencies(PlatformDependenciesRequest(address, targets, platform))` builds
+  the members among `targets` for the platform and checks their `platforms`. A tool that runs
+  during the build is built with `build_for_platform` for `KnownPlatforms.host`.
+- The `package` rule returns `package_for_platforms(PackageForPlatformsRequest(field_set))`.
+  Goals that run what they build, such as `run` and `test`, build for the host.

pants_backend_platforms-0.1.0/README.md

@@ -0,0 +1,60 @@
+# pants-backend-platforms
+
+A [Pants](https://www.pantsbuild.org) backend for building targets for more than one platform.
+It has no build rules of its own: language backends (such as pants-backend-cmake) use it to
+know which platforms to build and how to ask another backend for a dependency built for the
+same platform. The C and C++ toolchain for each platform is in [pants-backend-cc](../cc).
+
+This release targets Pants **2.32.x**. Install it with `pants-backend-platforms==0.1.0` in
+`[GLOBAL].plugins` in `pants.toml`, and enable `pants_backend_platforms` in
+`[GLOBAL].backend_packages`.
+
+**Status: alpha.**
+
+## Targets
+
+```python
+platform(name="linux-x86_64", os="linux", arch="x86_64")
+platform(name="windows-x86_64", os="windows", arch="x86_64")
+```
+
+- `platform`: `os` (`linux`, `windows`, `macos`) and `arch` (`x86_64`, `aarch64`). Everything
+  refers to a platform by its target name, so names are unique.
+- The host is the `platform` matching the machine Pants runs on. When several match, choose
+  with `[platforms].host`; when none does, there is an implicit `<os>-<arch>` platform.
+
+## Choosing what to build
+
+A target of a backend that supports platforms has a `platforms` field: the platforms it can be
+built for, the host alone when unset.
+
+```python
+cmake_target(name="app", project=":project", platforms=["linux-x86_64", "windows-x86_64"])
+```
+
+`pants package` builds the platforms in that list that are the host or in
+`[platforms].enabled`. The host's output keeps its usual path in `dist/`, and every other
+platform's goes under `dist/<platform>/`:
+
+```
+pants --platforms-enabled="['windows-x86_64']" package ::
+```
+
+A target built for a platform has its dependencies built for the same platform, enabled or not.
+A dependency whose `platforms` does not list it is an error naming both targets.
+
+Enable extra platforms where the packages are published rather than in `pants.toml`: whatever
+packages a target, such as a test's `runtime_package_dependencies` or an `archive`, gets every
+enabled platform too.
+
+## For backend authors
+
+- Make the field set a `PlatformBuildFieldSet` member, which brings the `platforms` field, and
+  register `UnionRule(PlatformBuildFieldSet, MyFieldSet)`. Its rule takes the field set and a
+  `TargetPlatform` and returns a `PlatformBuild`: the files at the paths `pants package` writes
+  them to for the host.
+- `build_platform_dependencies(PlatformDependenciesRequest(address, targets, platform))` builds
+  the members among `targets` for the platform and checks their `platforms`. A tool that runs
+  during the build is built with `build_for_platform` for `KnownPlatforms.host`.
+- The `package` rule returns `package_for_platforms(PackageForPlatformsRequest(field_set))`.
+  Goals that run what they build, such as `run` and `test`, build for the host.

pants_backend_platforms-0.1.0/pants_backend_platforms/register.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from pants_backend_platforms.target_types import PlatformTarget
+from pants_backend_platforms.util_rules import contract, lookup, platforms
+
+
+def target_types():
+    return [PlatformTarget]
+
+
+def rules():
+    return [*lookup.rules(), *platforms.rules(), *contract.rules()]

pants_backend_platforms-0.1.0/pants_backend_platforms/subsystems.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pants.option.option_types import StrListOption, StrOption
+from pants.option.subsystem import Subsystem
+from pants.util.strutil import softwrap
+
+
+class PlatformsSubsystem(Subsystem):
+    options_scope = "platforms"
+    help = "Which platforms a run builds."
+
+    enabled = StrListOption(
+        default=[],
+        help="Platforms `pants package` builds besides the host, for targets whose `platforms` list them.",
+    )
+    host = StrOption(
+        default=None,
+        help=softwrap(
+            """
+            The `platform` this machine is, when several match its os and arch. Unset, the only
+            match, or an implicit `<os>-<arch>` platform when none matches.
+            """
+        ),
+    )

pants_backend_platforms-0.1.0/pants_backend_platforms/target_types.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from pants.engine.target import (
+    COMMON_TARGET_FIELDS,
+    AsyncFieldMixin,
+    StringField,
+    StringSequenceField,
+    Target,
+)
+from pants.util.strutil import help_text
+
+
+class PlatformOsField(StringField):
+    alias = "os"
+    required = True
+    valid_choices = ("linux", "windows", "macos")
+    help = "The operating system."
+
+
+class PlatformArchField(StringField):
+    alias = "arch"
+    required = True
+    valid_choices = ("x86_64", "aarch64")
+    help = "The CPU architecture."
+
+
+class PlatformTarget(Target):
+    alias = "platform"
+    core_fields = (*COMMON_TARGET_FIELDS, PlatformOsField, PlatformArchField)
+    help = "A platform to build for, referred to by its target name, which is unique."
+
+
+class PlatformsField(StringSequenceField, AsyncFieldMixin):
+    alias = "platforms"
+    default = None
+    help = help_text(
+        """
+        The platforms this target can be built for, by name; unset, the host only. `pants
+        package` builds those that are the host or in `[platforms].enabled`.
+        """
+    )

pants_backend_platforms-0.1.0/pants_backend_platforms/util_rules/contract.py

@@ -0,0 +1,156 @@
+"""How a backend builds another backend's targets for the platform it is building for."""
+
+from __future__ import annotations
+
+import logging
+from abc import ABCMeta
+from dataclasses import dataclass
+
+from pants.core.goals.package import BuiltPackage, BuiltPackageArtifact
+from pants.engine.addresses import Address
+from pants.engine.environment import EnvironmentName
+from pants.engine.fs import (
+    EMPTY_DIGEST,
+    AddPrefix,
+    Digest,
+    DigestSubset,
+    GlobExpansionConjunction,
+    GlobMatchErrorBehavior,
+    MergeDigests,
+    PathGlobs,
+)
+from pants.engine.internals.graph import find_valid_field_sets
+from pants.engine.intrinsics import add_prefix, digest_subset_to_digest, merge_digests
+from pants.engine.rules import collect_rules, concurrently, implicitly, rule
+from pants.engine.target import FieldSet, FieldSetsPerTargetRequest, Target
+from pants.engine.unions import union
+from pants.util.frozendict import FrozenDict
+from pants.util.logging import LogLevel
+
+from pants_backend_platforms.target_types import PlatformsField
+from pants_backend_platforms.util_rules.platforms import (
+    KnownPlatforms,
+    SelectPlatformsRequest,
+    TargetPlatform,
+    select_platforms,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@union(in_scope_types=[EnvironmentName, TargetPlatform])
+@dataclass(frozen=True)
+class PlatformBuildFieldSet(FieldSet, metaclass=ABCMeta):
+    """A member's rule takes the field set and a `TargetPlatform` and returns a `PlatformBuild`
+    holding its files at the paths `pants package` writes them to for the host."""
+
+    platforms: PlatformsField
+
+
+@dataclass(frozen=True)
+class PlatformBuild:
+    digest: Digest
+    files: tuple[str, ...]
+
+
+def platform_build_files(build: PlatformBuild, description_of_origin: str) -> DigestSubset:
+    """The build's `files` alone; any file it does not hold is an error naming its origin."""
+    return DigestSubset(
+        build.digest,
+        PathGlobs(
+            build.files,
+            glob_match_error_behavior=GlobMatchErrorBehavior.error,
+            conjunction=GlobExpansionConjunction.all_match,
+            description_of_origin=description_of_origin,
+        ),
+    )
+
+
+@rule(polymorphic=True)
+async def build_for_platform(
+    field_set: PlatformBuildFieldSet, platform: TargetPlatform, environment_name: EnvironmentName
+) -> PlatformBuild:
+    raise NotImplementedError()
+
+
+@dataclass(frozen=True)
+class PlatformDependenciesRequest:
+    dependent: Address
+    targets: tuple[Target, ...]
+    """Targets that are not `PlatformBuildFieldSet` members are ignored."""
+    platform: TargetPlatform
+
+
+@dataclass(frozen=True)
+class PlatformDependencies:
+    builds: FrozenDict[Address, PlatformBuild]
+
+
+@rule(desc="Build dependencies for a platform", level=LogLevel.DEBUG)
+async def build_platform_dependencies(
+    request: PlatformDependenciesRequest, known: KnownPlatforms
+) -> PlatformDependencies:
+    per_target = await find_valid_field_sets(
+        FieldSetsPerTargetRequest(PlatformBuildFieldSet, request.targets), **implicitly()
+    )
+    members = []
+    for tgt, field_sets in zip(request.targets, per_target.collection):
+        if len(field_sets) > 1:
+            kinds = sorted(type(fs).__name__ for fs in field_sets)
+            raise ValueError(f"{tgt.address} matches several platform build field sets: {kinds}")
+        if not field_sets:
+            continue
+        listed = known.listed(field_sets[0].platforms)
+        if request.platform not in listed:
+            raise ValueError(
+                f"{request.dependent} is being built for {request.platform.name}, but its "
+                f"dependency {tgt.address} lists only {[p.name for p in listed]} in `platforms`."
+            )
+        members.append(field_sets[0])
+    builds = await concurrently(
+        build_for_platform(**implicitly({fs: PlatformBuildFieldSet, request.platform: TargetPlatform}))
+        for fs in members
+    )
+    return PlatformDependencies(FrozenDict({fs.address: b for fs, b in zip(members, builds)}))
+
+
+@dataclass(frozen=True)
+class PackageForPlatformsRequest:
+    field_set: PlatformBuildFieldSet
+
+
+@rule(desc="Package for each platform", level=LogLevel.DEBUG)
+async def package_for_platforms(request: PackageForPlatformsRequest, known: KnownPlatforms) -> BuiltPackage:
+    """The host build at its own paths, every other selected platform under `<platform>/`."""
+    field_set = request.field_set
+    selected = await select_platforms(SelectPlatformsRequest(field_set.platforms), **implicitly())
+    if not selected.platforms:
+        logger.info(
+            f"{field_set.address}: none of its `platforms` is the host ({known.host.name}) or "
+            "enabled, so nothing is packaged."
+        )
+        return BuiltPackage(EMPTY_DIGEST, ())
+    builds = await concurrently(
+        build_for_platform(**implicitly({field_set: PlatformBuildFieldSet, p: TargetPlatform}))
+        for p in selected.platforms
+    )
+    files = await concurrently(
+        digest_subset_to_digest(platform_build_files(b, f"the build of {field_set.address} for {p.name}"))
+        for p, b in zip(selected.platforms, builds)
+    )
+    digests, relpaths = [], []
+    for platform, build, digest in zip(selected.platforms, builds, files):
+        if platform == known.host:
+            digests.append(digest)
+            relpaths.extend(build.files)
+        else:
+            digests.append(await add_prefix(AddPrefix(digest, platform.name)))
+            relpaths.extend(f"{platform.name}/{f}" for f in build.files)
+    return BuiltPackage(
+        await merge_digests(MergeDigests(digests)),
+        tuple(BuiltPackageArtifact(relpath=r) for r in relpaths),
+    )
+
+
+def rules():
+    return collect_rules()

pants_backend_platforms-0.1.0/pants_backend_platforms/util_rules/lookup.py

@@ -0,0 +1,57 @@
+"""The targets of one type in the repository, without `AllTargets`.
+
+`AllTargets` generates every target, so a rule that awaits it cannot run during target
+generation (it would wait on itself). Reading BUILD files and constructing only the targets of
+one alias avoids that, and is cheaper. It matches the alias as written in BUILD files, so targets
+of a subclass registered under another alias are not found.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pants.base.specs import RawSpecsWithoutFileOwners, RecursiveGlobSpec
+from pants.engine.collection import Collection
+from pants.engine.internals.graph import (
+    address_families_from_raw_specs_without_file_owners,
+    resolve_target_parametrizations,
+)
+from pants.engine.internals.parametrize import _TargetParametrizationsRequest
+from pants.engine.rules import collect_rules, concurrently, implicitly, rule
+from pants.engine.target import Target
+from pants.util.logging import LogLevel
+
+
+@dataclass(frozen=True)
+class TargetsOfAliasRequest:
+    alias: str
+
+
+class TargetsOfAlias(Collection[Target]):
+    pass
+
+
+@rule(desc="Find targets of one type", level=LogLevel.DEBUG)
+async def targets_of_alias(request: TargetsOfAliasRequest) -> TargetsOfAlias:
+    families = await address_families_from_raw_specs_without_file_owners(
+        RawSpecsWithoutFileOwners(
+            recursive_globs=(RecursiveGlobSpec(""),),
+            description_of_origin=f"the `{request.alias}` targets",
+        ),
+        **implicitly(),
+    )
+    # Private, but the only input `resolve_target_parametrizations` takes; Pants' own
+    # `resolve_all_generator_target_requests` builds it the same way.
+    parametrizations = await concurrently(
+        resolve_target_parametrizations(
+            _TargetParametrizationsRequest(address, f"the `{request.alias}` targets"), **implicitly()
+        )
+        for family in families
+        for address, adaptor in family.addresses_to_target_adaptors.items()
+        if adaptor.type_alias == request.alias
+    )
+    return TargetsOfAlias(t for p in parametrizations for t in p.all if not t.address.is_generated_target)
+
+
+def rules():
+    return collect_rules()

pants_backend_platforms-0.1.0/pants_backend_platforms/util_rules/platforms.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pants.engine.platform import Platform
+from pants.engine.rules import collect_rules, implicitly, rule
+from pants.util.frozendict import FrozenDict
+from pants.util.logging import LogLevel
+
+from pants_backend_platforms.subsystems import PlatformsSubsystem
+from pants_backend_platforms.target_types import (
+    PlatformArchField,
+    PlatformOsField,
+    PlatformsField,
+    PlatformTarget,
+)
+from pants_backend_platforms.util_rules.lookup import TargetsOfAliasRequest, targets_of_alias
+
+_MACHINES = {
+    Platform.linux_x86_64: ("linux", "x86_64"),
+    Platform.linux_arm64: ("linux", "aarch64"),
+    Platform.macos_x86_64: ("macos", "x86_64"),
+    Platform.macos_arm64: ("macos", "aarch64"),
+}
+
+
+@dataclass(frozen=True, order=True)
+class TargetPlatform:
+    name: str
+    os: str
+    arch: str
+
+
+@dataclass(frozen=True)
+class KnownPlatforms:
+    by_name: FrozenDict[str, TargetPlatform]
+    host: TargetPlatform
+
+    def unknown(self, name: str, origin: str) -> str:
+        return f"{origin}: unknown platform `{name}`; known: {sorted(self.by_name)}"
+
+    def get(self, name: str, origin: str) -> TargetPlatform:
+        platform = self.by_name.get(name)
+        if platform is None:
+            raise ValueError(self.unknown(name, origin))
+        return platform
+
+    def listed(self, field: PlatformsField) -> tuple[TargetPlatform, ...]:
+        """The platforms a `platforms` field names, the host when unset."""
+        origin = f"the `platforms` field of {field.address}"
+        names = dict.fromkeys(field.value or (self.host.name,))
+        return tuple(self.get(name, origin) for name in names)
+
+
+@rule(desc="Find the platforms", level=LogLevel.DEBUG)
+async def known_platforms(platform: Platform, subsystem: PlatformsSubsystem) -> KnownPlatforms:
+    if platform not in _MACHINES:
+        raise ValueError(f"pants_backend_platforms does not support Pants on {platform.value}.")
+    os_, arch = _MACHINES[platform]
+    platforms = await targets_of_alias(TargetsOfAliasRequest(PlatformTarget.alias), **implicitly())
+    by_name: dict[str, TargetPlatform] = {}
+    for tgt in platforms:
+        name = tgt.address.target_name
+        if name in by_name:
+            raise ValueError(f"Two `platform` targets are named `{name}`.")
+        by_name[name] = TargetPlatform(name, tgt[PlatformOsField].value, tgt[PlatformArchField].value)
+
+    if subsystem.host:
+        host = by_name.get(subsystem.host)
+        if host is None:
+            raise ValueError(
+                f"[platforms].host: unknown platform `{subsystem.host}`; known: {sorted(by_name)}"
+            )
+        if (host.os, host.arch) != (os_, arch):
+            raise ValueError(
+                f"[platforms].host is `{host.name}` ({host.os}, {host.arch}), but this machine is "
+                f"({os_}, {arch})."
+            )
+        return KnownPlatforms(FrozenDict(by_name), host)
+
+    matches = sorted(name for name, p in by_name.items() if (p.os, p.arch) == (os_, arch))
+    if len(matches) > 1:
+        raise ValueError(
+            f"Several `platform` targets match this machine ({os_}, {arch}): {matches}. Choose "
+            "one with `[platforms].host`."
+        )
+    if matches:
+        return KnownPlatforms(FrozenDict(by_name), by_name[matches[0]])
+    host = TargetPlatform(f"{os_}-{arch}", os_, arch)
+    if host.name in by_name:
+        raise ValueError(
+            f"No `platform` matches this machine ({os_}, {arch}), and the implicit host's name "
+            f"`{host.name}` is taken by another platform."
+        )
+    return KnownPlatforms(FrozenDict({**by_name, host.name: host}), host)
+
+
+@dataclass(frozen=True)
+class SelectPlatformsRequest:
+    platforms: PlatformsField
+
+
+@dataclass(frozen=True)
+class SelectedPlatforms:
+    platforms: tuple[TargetPlatform, ...]
+
+
+@rule
+async def select_platforms(
+    request: SelectPlatformsRequest, known: KnownPlatforms, subsystem: PlatformsSubsystem
+) -> SelectedPlatforms:
+    enabled = {known.host}
+    enabled.update(known.get(name, "[platforms].enabled") for name in subsystem.enabled)
+    return SelectedPlatforms(tuple(p for p in known.listed(request.platforms) if p in enabled))
+
+
+def rules():
+    return collect_rules()

pants_backend_platforms-0.1.0/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "pants_backend_platforms"
+description = "Multi-platform builds for Pants backends: platform targets and a contract for building dependencies per platform."
+version = "0.1.0"
+requires-python = ">=3.11"
+authors = [
+    { name = "Tom Solberg", email = "me@sbg.dev" },
+]
+dependencies = []
+readme = "README.md"
+keywords = [
+    "pantsbuild",
+    "pants",
+    "backend",
+    "cross-compilation",
+    "platforms",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python",
+    "Topic :: Software Development :: Build Tools",
+]
+
+[project.license]
+file = "LICENSE-MIT.txt"
+
+[project.urls]
+Repository = "https://github.com/tgolsson/pants-backends"
+Code = "https://github.com/tgolsson/pants-backends/tree/main/pants-plugins/platforms"
+Changelog = "https://github.com/tgolsson/pants-backends/tree/main/pants-plugins/platforms/CHANGELOG.md"
+
+[tool.pdm.build]
+includes = [
+    "pants_backend_platforms",
+]
+
+[tool.isort]
+profile = "black"
+known_first_party = [
+    "pants_backend_platforms",
+]
+line_length = 100
+include_trailing_comma = true
+
+[tool.black]
+line-length = 100
+
+[build-system]
+requires = [
+    "pdm-backend>2.0",
+]
+build-backend = "pdm.backend"