pants-ty 0.1.0__tar.gz

pants_ty-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vasile Razdalovschi
+
+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_ty-0.1.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: pants-ty
+Version: 0.1.0
+Summary: A Pants check backend for the Astral ty Python type checker.
+Author: Vasile Razdalovschi
+License-Expression: MIT
+Project-URL: Repository, https://github.com/vrazdalovschi/pants-ty-plugin
+Project-URL: Issues, https://github.com/vrazdalovschi/pants-ty-plugin/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pantsbuild.pants<2.32,>=2.31
+Dynamic: license-file
+
+# pants-ty-plugin
+
+`pants-ty-plugin` adds a Pants `check` backend for [Astral ty](https://docs.astral.sh/ty/).
+
+It is designed for Pants `2.31.x` and currently supports Linux and macOS. The backend installs
+`ty` as an external binary, then runs it with:
+
+- a resolve-backed Python environment for third-party dependencies
+- Pants source roots as `--extra-search-path` entries for first-party imports
+
+That means `ty` can resolve imports that Pants already knows about.
+
+## Features
+
+- `pants check --only=ty ...`
+- `skip_ty = true` on Python targets
+- `ty.toml` discovery
+- `[tool.ty]` discovery from `pyproject.toml`
+- resolve-aware `--python`
+- source-root-aware `--extra-search-path`
+
+## Install
+
+### Option 1: vendor the plugin into a private repo
+
+Copy only the Python package files from `pants-plugins/pants_ty/` into your repo's
+`pants-plugins/pants_ty/` directory:
+
+- `__init__.py`
+- `register.py`
+- `rules.py`
+- `skip_field.py`
+- `subsystem.py`
+
+Do not copy this plugin repo's development-only files:
+
+- `pants-plugins/BUILD`
+- `pants-plugins/pants_ty/BUILD`
+- `pants-plugins/lock.txt`
+- `tests/`
+- this repo's `pants.toml`, `pyproject.toml`, or GitHub workflow files
+
+Those files are only for developing and releasing `pants-ty-plugin` itself. A consuming repo
+should use its own resolves, lockfiles, and test setup.
+
+Then configure:
+
+```toml
+[GLOBAL]
+pants_version = "2.31.0"
+backend_packages = [
+  "pants.backend.python",
+  "pants_ty",
+]
+pythonpath = ["%(buildroot)s/pants-plugins"]
+```
+
+If you accidentally copy the dev `BUILD` files too, you may see an error like:
+
+```text
+UnrecognizedResolveNamesError: ... resolve ... pants-plugins
+```
+
+That means your consuming repo picked up this repo's internal development resolve. Remove the
+copied `BUILD` files and keep only the plugin Python modules.
+
+### Option 2: install as a published plugin
+
+Once the package is published, use:
+
+```toml
+[GLOBAL]
+plugins = ["pants-ty==0.1.0"]
+backend_packages = [
+  "pants.backend.python",
+  "pants_ty",
+]
+```
+
+## Configure
+
+Create either `ty.toml` or add `[tool.ty]` to `pyproject.toml`.
+
+Example:
+
+```toml
+[tool.ty]
+exclude = [".pants.d", "dist"]
+```
+
+Pants exposes the plugin options under `[ty]`:
+
+```toml
+[ty]
+args = ["--output-format=concise"]
+config_discovery = true
+```
+
+Useful commands:
+
+```bash
+pants help ty
+pants check --only=ty ::
+pants check --only=ty path/to/pkg::
+```
+
+To skip a target:
+
+```python
+python_sources(
+  name="lib",
+  skip_ty=True,
+)
+```
+
+## Development
+
+This repo uses Pants to lint, test, and dogfood the plugin itself.
+
+```bash
+ruff check pants-plugins tests
+pants test ::
+pants check ::
+```
+
+To build a distributable wheel and sdist:
+
+```bash
+python -m build
+```
+
+## Repository layout
+
+- `pants-plugins/pants_ty`: plugin source
+- `tests/pants_ty`: unit and integration tests
+- `pants.toml`: local development config
+- `pants.ci.toml`: CI-specific Pants settings
+
+## Notes
+
+- The Pants plugin API is not stable across minor versions. This repo currently targets
+  Pants `2.31.x`.
+- The backend only resolves imports that Pants already knows through source roots and
+  target resolves.

pants_ty-0.1.0/README.md

@@ -0,0 +1,144 @@
+# pants-ty-plugin
+
+`pants-ty-plugin` adds a Pants `check` backend for [Astral ty](https://docs.astral.sh/ty/).
+
+It is designed for Pants `2.31.x` and currently supports Linux and macOS. The backend installs
+`ty` as an external binary, then runs it with:
+
+- a resolve-backed Python environment for third-party dependencies
+- Pants source roots as `--extra-search-path` entries for first-party imports
+
+That means `ty` can resolve imports that Pants already knows about.
+
+## Features
+
+- `pants check --only=ty ...`
+- `skip_ty = true` on Python targets
+- `ty.toml` discovery
+- `[tool.ty]` discovery from `pyproject.toml`
+- resolve-aware `--python`
+- source-root-aware `--extra-search-path`
+
+## Install
+
+### Option 1: vendor the plugin into a private repo
+
+Copy only the Python package files from `pants-plugins/pants_ty/` into your repo's
+`pants-plugins/pants_ty/` directory:
+
+- `__init__.py`
+- `register.py`
+- `rules.py`
+- `skip_field.py`
+- `subsystem.py`
+
+Do not copy this plugin repo's development-only files:
+
+- `pants-plugins/BUILD`
+- `pants-plugins/pants_ty/BUILD`
+- `pants-plugins/lock.txt`
+- `tests/`
+- this repo's `pants.toml`, `pyproject.toml`, or GitHub workflow files
+
+Those files are only for developing and releasing `pants-ty-plugin` itself. A consuming repo
+should use its own resolves, lockfiles, and test setup.
+
+Then configure:
+
+```toml
+[GLOBAL]
+pants_version = "2.31.0"
+backend_packages = [
+  "pants.backend.python",
+  "pants_ty",
+]
+pythonpath = ["%(buildroot)s/pants-plugins"]
+```
+
+If you accidentally copy the dev `BUILD` files too, you may see an error like:
+
+```text
+UnrecognizedResolveNamesError: ... resolve ... pants-plugins
+```
+
+That means your consuming repo picked up this repo's internal development resolve. Remove the
+copied `BUILD` files and keep only the plugin Python modules.
+
+### Option 2: install as a published plugin
+
+Once the package is published, use:
+
+```toml
+[GLOBAL]
+plugins = ["pants-ty==0.1.0"]
+backend_packages = [
+  "pants.backend.python",
+  "pants_ty",
+]
+```
+
+## Configure
+
+Create either `ty.toml` or add `[tool.ty]` to `pyproject.toml`.
+
+Example:
+
+```toml
+[tool.ty]
+exclude = [".pants.d", "dist"]
+```
+
+Pants exposes the plugin options under `[ty]`:
+
+```toml
+[ty]
+args = ["--output-format=concise"]
+config_discovery = true
+```
+
+Useful commands:
+
+```bash
+pants help ty
+pants check --only=ty ::
+pants check --only=ty path/to/pkg::
+```
+
+To skip a target:
+
+```python
+python_sources(
+  name="lib",
+  skip_ty=True,
+)
+```
+
+## Development
+
+This repo uses Pants to lint, test, and dogfood the plugin itself.
+
+```bash
+ruff check pants-plugins tests
+pants test ::
+pants check ::
+```
+
+To build a distributable wheel and sdist:
+
+```bash
+python -m build
+```
+
+## Repository layout
+
+- `pants-plugins/pants_ty`: plugin source
+- `tests/pants_ty`: unit and integration tests
+- `pants.toml`: local development config
+- `pants.ci.toml`: CI-specific Pants settings
+
+## Notes
+
+- The Pants plugin API is not stable across minor versions. This repo currently targets
+  Pants `2.31.x`.
+- The backend only resolves imports that Pants already knows through source roots and
+  target resolves.

pants_ty-0.1.0/pants-plugins/pants_ty/__init__.py

@@ -0,0 +1,2 @@
+from __future__ import annotations
+__version__ = "0.1.0"

pants_ty-0.1.0/pants-plugins/pants_ty/register.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from pants.engine.rules import Rule
+from pants.engine.unions import UnionRule
+
+from pants_ty import rules as ty_rules
+from pants_ty import skip_field, subsystem
+
+
+def rules() -> Iterable[Rule | UnionRule]:
+    return (*subsystem.rules(), *skip_field.rules(), *ty_rules.rules())

pants_ty-0.1.0/pants-plugins/pants_ty/rules.py

@@ -0,0 +1,291 @@
+from __future__ import annotations
+
+import os
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+
+from pants.backend.python.subsystems.setup import PythonSetup
+from pants.backend.python.target_types import (
+    InterpreterConstraintsField,
+    PythonResolveField,
+    PythonSourceField,
+)
+from pants.backend.python.util_rules import pex_from_targets
+from pants.backend.python.util_rules.interpreter_constraints import InterpreterConstraints
+from pants.backend.python.util_rules.partition import (
+    _partition_by_interpreter_constraints_and_resolve,
+)
+from pants.backend.python.util_rules.pex import (
+    PexRequest,
+    VenvPexProcess,
+    VenvPexRequest,
+    create_pex,
+    create_venv_pex,
+)
+from pants.backend.python.util_rules.pex_environment import PexEnvironment
+from pants.backend.python.util_rules.pex_from_targets import RequirementsPexRequest
+from pants.backend.python.util_rules.python_sources import (
+    PythonSourceFilesRequest,
+    prepare_python_sources,
+)
+from pants.core.goals.check import CheckRequest, CheckResult, CheckResults
+from pants.core.util_rules import config_files
+from pants.core.util_rules.config_files import find_config_file
+from pants.core.util_rules.external_tool import download_external_tool
+from pants.core.util_rules.source_files import SourceFilesRequest, determine_source_files
+from pants.engine.collection import Collection
+from pants.engine.fs import MergeDigests
+from pants.engine.internals.graph import resolve_coarsened_targets
+from pants.engine.intrinsics import execute_process, merge_digests
+from pants.engine.platform import Platform
+from pants.engine.process import Process, ProcessCacheScope, execute_process_or_raise
+from pants.engine.rules import Rule, collect_rules, concurrently, implicitly, rule
+from pants.engine.target import (
+    CoarsenedTargets,
+    CoarsenedTargetsRequest,
+    FieldSet,
+    Target,
+)
+from pants.engine.unions import UnionRule
+from pants.util.logging import LogLevel
+from pants.util.ordered_set import FrozenOrderedSet, OrderedSet
+from pants.util.strutil import pluralize
+
+from pants_ty.skip_field import SkipTyField
+from pants_ty.subsystem import Ty
+
+
+def _python_version_args(
+    *, python_version: str | None, user_args: Sequence[str]
+) -> tuple[str, ...]:
+    if python_version is None:
+        return ()
+    if any(
+        arg.startswith("--python-version=") or arg.startswith("--target-version=")
+        for arg in user_args
+    ):
+        return ()
+    return (f"--python-version={python_version}",)
+
+
+def _extra_search_path_args(source_roots: Sequence[str]) -> tuple[str, ...]:
+    unique_source_roots = tuple(dict.fromkeys(source_roots))
+    return tuple(f"--extra-search-path={source_root}" for source_root in unique_source_roots)
+
+
+def _batch_input_paths(
+    paths: Sequence[str], *, max_paths_per_batch: int
+) -> tuple[tuple[str, ...], ...]:
+    if max_paths_per_batch <= 0:
+        raise ValueError("max_paths_per_batch must be positive")
+    if not paths:
+        return ()
+    return tuple(
+        tuple(paths[index : index + max_paths_per_batch])
+        for index in range(0, len(paths), max_paths_per_batch)
+    )
+
+
+@dataclass(frozen=True)
+class TyFieldSet(FieldSet):
+    required_fields = (PythonSourceField,)
+
+    sources: PythonSourceField
+    resolve: PythonResolveField
+    interpreter_constraints: InterpreterConstraintsField
+
+    @classmethod
+    def opt_out(cls, tgt: Target) -> bool:
+        return tgt.get(SkipTyField).value
+
+
+class TyRequest(CheckRequest):
+    field_set_type = TyFieldSet
+    tool_name = Ty.options_scope
+
+
+@dataclass(frozen=True)
+class TyPartition:
+    field_sets: FrozenOrderedSet[TyFieldSet]
+    root_targets: CoarsenedTargets
+    resolve_description: str | None
+    interpreter_constraints: InterpreterConstraints
+
+    def description(self) -> str:
+        ics = str(sorted(str(c) for c in self.interpreter_constraints))
+        return f"{self.resolve_description}, {ics}" if self.resolve_description else ics
+
+
+class TyPartitions(Collection[TyPartition]):
+    pass
+
+
+@rule(
+    desc="Determine if it is necessary to partition Ty's input",
+    level=LogLevel.DEBUG,
+)
+async def ty_determine_partitions(
+    request: TyRequest,
+    ty: Ty,
+    python_setup: PythonSetup,
+) -> TyPartitions:
+    resolve_and_interpreter_constraints_to_field_sets = (
+        _partition_by_interpreter_constraints_and_resolve(request.field_sets, python_setup)
+    )
+
+    coarsened_targets = await resolve_coarsened_targets(
+        CoarsenedTargetsRequest(field_set.address for field_set in request.field_sets),
+        **implicitly(),
+    )
+    coarsened_targets_by_address = coarsened_targets.by_address()
+
+    return TyPartitions(
+        TyPartition(
+            FrozenOrderedSet(field_sets),
+            CoarsenedTargets(
+                OrderedSet(
+                    coarsened_targets_by_address[field_set.address] for field_set in field_sets
+                )
+            ),
+            resolve if len(python_setup.resolves) > 1 else None,
+            interpreter_constraints or ty.interpreter_constraints,
+        )
+        for (resolve, interpreter_constraints), field_sets in sorted(
+            resolve_and_interpreter_constraints_to_field_sets.items()
+        )
+    )
+
+
+@rule(desc="Typecheck one Ty partition", level=LogLevel.DEBUG)
+async def ty_typecheck_partition(
+    partition: TyPartition,
+    ty: Ty,
+    platform: Platform,
+    pex_environment: PexEnvironment,
+    python_setup: PythonSetup,
+) -> CheckResult:
+    (
+        ty_tool,
+        config_files_snapshot,
+        root_sources,
+        transitive_sources,
+        requirements_pex,
+    ) = await concurrently(
+        download_external_tool(ty.get_request(platform)),
+        find_config_file(ty.config_request()),
+        determine_source_files(SourceFilesRequest(fs.sources for fs in partition.field_sets)),
+        prepare_python_sources(
+            PythonSourceFilesRequest(partition.root_targets.closure()), **implicitly()
+        ),
+        create_pex(
+            **implicitly(
+                RequirementsPexRequest(
+                    (fs.address for fs in partition.field_sets),
+                    hardcoded_interpreter_constraints=partition.interpreter_constraints,
+                )
+            )
+        ),
+    )
+
+    complete_pex_env = pex_environment.in_workspace()
+    requirements_venv_pex = await create_venv_pex(
+        VenvPexRequest(
+            PexRequest(
+                output_filename="requirements_venv.pex",
+                internal_only=True,
+                pex_path=[requirements_pex],
+                interpreter_constraints=partition.interpreter_constraints,
+            ),
+            complete_pex_env,
+        ),
+        **implicitly(),
+    )
+
+    _ = await execute_process_or_raise(
+        **implicitly(
+            VenvPexProcess(
+                requirements_venv_pex,
+                description="Force Ty requirements venv to materialize",
+                argv=["-c", "''"],
+                cache_scope=ProcessCacheScope.PER_SESSION,
+            )
+        )
+    )
+
+    input_digest = await merge_digests(
+        MergeDigests(
+            (
+                transitive_sources.source_files.snapshot.digest,
+                config_files_snapshot.snapshot.digest,
+                requirements_venv_pex.digest,
+            )
+        )
+    )
+
+    immutable_input_key = "__ty_tool"
+    exe_path = os.path.join(immutable_input_key, ty_tool.exe)
+    requirements_venv_path = os.path.join(
+        complete_pex_env.pex_root, requirements_venv_pex.venv_rel_dir
+    )
+
+    python_version = partition.interpreter_constraints.minimum_python_version(
+        python_setup.interpreter_versions_universe
+    )
+    config_args = (f"--config-file={ty.config}",) if ty.config else ()
+    common_args = (
+        "check",
+        *config_args,
+        f"--python={requirements_venv_path}",
+        *_python_version_args(python_version=python_version, user_args=ty.args),
+        *_extra_search_path_args(transitive_sources.source_roots),
+        *ty.args,
+    )
+    path_batches = _batch_input_paths(tuple(root_sources.snapshot.files), max_paths_per_batch=512)
+
+    if not path_batches:
+        return CheckResult(0, "", "", partition_description=partition.description())
+
+    batch_results = await concurrently(
+        execute_process(
+            Process(
+                argv=(exe_path, *common_args, *path_batch),
+                input_digest=input_digest,
+                immutable_input_digests={immutable_input_key: ty_tool.digest},
+                description=f"Run Ty on {pluralize(len(path_batch), 'file')}.",
+                level=LogLevel.DEBUG,
+            ),
+            **implicitly(),
+        )
+        for path_batch in path_batches
+    )
+
+    return CheckResult(
+        exit_code=max(result.exit_code for result in batch_results),
+        stdout="".join(result.stdout.decode() for result in batch_results),
+        stderr="".join(result.stderr.decode() for result in batch_results),
+        partition_description=partition.description(),
+    )
+
+
+@rule(desc="Typecheck using Ty", level=LogLevel.DEBUG)
+async def ty_typecheck(
+    request: TyRequest,
+    ty: Ty,
+) -> CheckResults:
+    if ty.skip:
+        return CheckResults([], checker_name=request.tool_name)
+
+    partitions = await ty_determine_partitions(request, **implicitly())
+    partitioned_results = await concurrently(
+        ty_typecheck_partition(partition, **implicitly()) for partition in partitions
+    )
+    return CheckResults(partitioned_results, checker_name=request.tool_name)
+
+
+def rules() -> Iterable[Rule | UnionRule]:
+    return (
+        *collect_rules(),
+        *config_files.rules(),
+        *pex_from_targets.rules(),
+        UnionRule(CheckRequest, TyRequest),
+    )

pants_ty-0.1.0/pants-plugins/pants_ty/skip_field.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from pants.backend.python.target_types import (
+    PythonSourceTarget,
+    PythonSourcesGeneratorTarget,
+    PythonTestTarget,
+    PythonTestsGeneratorTarget,
+    PythonTestUtilsGeneratorTarget,
+)
+from pants.engine.rules import Rule
+from pants.engine.target import BoolField
+from pants.engine.unions import UnionRule
+
+
+class SkipTyField(BoolField):
+    alias = "skip_ty"
+    default = False
+    help = "If true, don't run Ty on this target's code."
+
+
+def rules() -> Iterable[Rule | UnionRule]:
+    return (
+        PythonSourcesGeneratorTarget.register_plugin_field(SkipTyField),
+        PythonSourceTarget.register_plugin_field(SkipTyField),
+        PythonTestsGeneratorTarget.register_plugin_field(SkipTyField),
+        PythonTestTarget.register_plugin_field(SkipTyField),
+        PythonTestUtilsGeneratorTarget.register_plugin_field(SkipTyField),
+    )

pants_ty-0.1.0/pants-plugins/pants_ty/subsystem.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from pants.backend.python.util_rules.interpreter_constraints import InterpreterConstraints
+from pants.core.goals.resolves import ExportableTool
+from pants.core.util_rules.config_files import ConfigFilesRequest
+from pants.core.util_rules.external_tool import TemplatedExternalTool
+from pants.engine.platform import Platform
+from pants.engine.rules import Rule, collect_rules
+from pants.engine.unions import UnionRule
+from pants.option.option_types import (
+    ArgsListOption,
+    BoolOption,
+    FileOption,
+    SkipOption,
+    StrListOption,
+)
+from pants.util.strutil import softwrap
+
+
+class Ty(TemplatedExternalTool):
+    options_scope = "ty"
+    name = "Ty"
+    help = softwrap(
+        """
+        The Ty Python type checker (https://docs.astral.sh/ty/).
+        """
+    )
+
+    default_version = "0.0.24"
+    default_known_versions = [
+        "0.0.24|linux_arm64|f51f5c0fcdf06f22cf74edbc15fddb2614466a3237ec12247e6aaf6215d349ee|9778744",
+        "0.0.24|linux_x86_64|dbb8d08643dc2ce7dee5a1c482e1ab240d4e6eb5ae7df08b77f59df8c6374014|10612104",
+        "0.0.24|macos_arm64|91709778a139350dc890e6048b042bc0800b04f1cb0cd4a636af22673fa84c1a|9323636",
+        "0.0.24|macos_x86_64|3c0f93d0b578b556f4a7765714f6e875f836f8f0d0111fdc786b2adc79110a4d|9957953",
+    ]
+    default_url_template = (
+        "https://github.com/astral-sh/ty/releases/download/{version}/ty-{platform}.tar.gz"
+    )
+    default_url_platform_mapping = {
+        "linux_arm64": "aarch64-unknown-linux-musl",
+        "linux_x86_64": "x86_64-unknown-linux-musl",
+        "macos_arm64": "aarch64-apple-darwin",
+        "macos_x86_64": "x86_64-apple-darwin",
+    }
+
+    skip = SkipOption("check")
+    args = ArgsListOption(example="--error-on-warning --output-format=concise")
+    config = FileOption(
+        default=None,
+        advanced=True,
+        help=softwrap(
+            """
+            Path to a `ty.toml` file to use for configuration.
+
+            Setting this option disables `[ty].config_discovery`.
+            """
+        ),
+    )
+    config_discovery = BoolOption(
+        default=True,
+        advanced=True,
+        help=softwrap(
+            """
+            If true, Pants will include relevant Ty config files during runs
+            (`ty.toml` and `pyproject.toml` containing `[tool.ty]`).
+            """
+        ),
+    )
+    _interpreter_constraints = StrListOption(
+        advanced=True,
+        default=["CPython>=3.8,<3.15"],
+        help="Python interpreter constraints for Ty.",
+    )
+
+    def generate_exe(self, plat: Platform) -> str:
+        return f"ty-{self.default_url_platform_mapping[plat.value]}/ty"
+
+    @property
+    def interpreter_constraints(self) -> InterpreterConstraints:
+        return InterpreterConstraints(self._interpreter_constraints)
+
+    def config_request(self) -> ConfigFilesRequest:
+        return ConfigFilesRequest(
+            specified=self.config,
+            specified_option_name=f"{self.options_scope}.config",
+            discovery=self.config_discovery,
+            check_existence=["ty.toml"],
+            check_content={"pyproject.toml": b"[tool.ty"},
+        )
+
+
+def rules() -> Iterable[Rule | UnionRule]:
+    return (
+        *collect_rules(),
+        *Ty.rules(),
+        UnionRule(ExportableTool, Ty),
+    )

pants_ty-0.1.0/pants-plugins/pants_ty.egg-info/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: pants-ty
+Version: 0.1.0
+Summary: A Pants check backend for the Astral ty Python type checker.
+Author: Vasile Razdalovschi
+License-Expression: MIT
+Project-URL: Repository, https://github.com/vrazdalovschi/pants-ty-plugin
+Project-URL: Issues, https://github.com/vrazdalovschi/pants-ty-plugin/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pantsbuild.pants<2.32,>=2.31
+Dynamic: license-file
+
+# pants-ty-plugin
+
+`pants-ty-plugin` adds a Pants `check` backend for [Astral ty](https://docs.astral.sh/ty/).
+
+It is designed for Pants `2.31.x` and currently supports Linux and macOS. The backend installs
+`ty` as an external binary, then runs it with:
+
+- a resolve-backed Python environment for third-party dependencies
+- Pants source roots as `--extra-search-path` entries for first-party imports
+
+That means `ty` can resolve imports that Pants already knows about.
+
+## Features
+
+- `pants check --only=ty ...`
+- `skip_ty = true` on Python targets
+- `ty.toml` discovery
+- `[tool.ty]` discovery from `pyproject.toml`
+- resolve-aware `--python`
+- source-root-aware `--extra-search-path`
+
+## Install
+
+### Option 1: vendor the plugin into a private repo
+
+Copy only the Python package files from `pants-plugins/pants_ty/` into your repo's
+`pants-plugins/pants_ty/` directory:
+
+- `__init__.py`
+- `register.py`
+- `rules.py`
+- `skip_field.py`
+- `subsystem.py`
+
+Do not copy this plugin repo's development-only files:
+
+- `pants-plugins/BUILD`
+- `pants-plugins/pants_ty/BUILD`
+- `pants-plugins/lock.txt`
+- `tests/`
+- this repo's `pants.toml`, `pyproject.toml`, or GitHub workflow files
+
+Those files are only for developing and releasing `pants-ty-plugin` itself. A consuming repo
+should use its own resolves, lockfiles, and test setup.
+
+Then configure:
+
+```toml
+[GLOBAL]
+pants_version = "2.31.0"
+backend_packages = [
+  "pants.backend.python",
+  "pants_ty",
+]
+pythonpath = ["%(buildroot)s/pants-plugins"]
+```
+
+If you accidentally copy the dev `BUILD` files too, you may see an error like:
+
+```text
+UnrecognizedResolveNamesError: ... resolve ... pants-plugins
+```
+
+That means your consuming repo picked up this repo's internal development resolve. Remove the
+copied `BUILD` files and keep only the plugin Python modules.
+
+### Option 2: install as a published plugin
+
+Once the package is published, use:
+
+```toml
+[GLOBAL]
+plugins = ["pants-ty==0.1.0"]
+backend_packages = [
+  "pants.backend.python",
+  "pants_ty",
+]
+```
+
+## Configure
+
+Create either `ty.toml` or add `[tool.ty]` to `pyproject.toml`.
+
+Example:
+
+```toml
+[tool.ty]
+exclude = [".pants.d", "dist"]
+```
+
+Pants exposes the plugin options under `[ty]`:
+
+```toml
+[ty]
+args = ["--output-format=concise"]
+config_discovery = true
+```
+
+Useful commands:
+
+```bash
+pants help ty
+pants check --only=ty ::
+pants check --only=ty path/to/pkg::
+```
+
+To skip a target:
+
+```python
+python_sources(
+  name="lib",
+  skip_ty=True,
+)
+```
+
+## Development
+
+This repo uses Pants to lint, test, and dogfood the plugin itself.
+
+```bash
+ruff check pants-plugins tests
+pants test ::
+pants check ::
+```
+
+To build a distributable wheel and sdist:
+
+```bash
+python -m build
+```
+
+## Repository layout
+
+- `pants-plugins/pants_ty`: plugin source
+- `tests/pants_ty`: unit and integration tests
+- `pants.toml`: local development config
+- `pants.ci.toml`: CI-specific Pants settings
+
+## Notes
+
+- The Pants plugin API is not stable across minor versions. This repo currently targets
+  Pants `2.31.x`.
+- The backend only resolves imports that Pants already knows through source roots and
+  target resolves.

pants_ty-0.1.0/pants-plugins/pants_ty.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+pants-plugins/pants_ty/__init__.py
+pants-plugins/pants_ty/register.py
+pants-plugins/pants_ty/rules.py
+pants-plugins/pants_ty/skip_field.py
+pants-plugins/pants_ty/subsystem.py
+pants-plugins/pants_ty.egg-info/PKG-INFO
+pants-plugins/pants_ty.egg-info/SOURCES.txt
+pants-plugins/pants_ty.egg-info/dependency_links.txt
+pants-plugins/pants_ty.egg-info/requires.txt
+pants-plugins/pants_ty.egg-info/top_level.txt

pants_ty-0.1.0/pants-plugins/pants_ty.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pants_ty-0.1.0/pants-plugins/pants_ty.egg-info/requires.txt

@@ -0,0 +1 @@
+pantsbuild.pants<2.32,>=2.31

pants_ty-0.1.0/pants-plugins/pants_ty.egg-info/top_level.txt

@@ -0,0 +1 @@
+pants_ty

pants_ty-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pants-ty"
+version = "0.1.0"
+description = "A Pants check backend for the Astral ty Python type checker."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{name = "Vasile Razdalovschi"}]
+dependencies = ["pantsbuild.pants>=2.31,<2.32"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Topic :: Software Development :: Build Tools",
+]
+
+[project.urls]
+Repository = "https://github.com/vrazdalovschi/pants-ty-plugin"
+Issues = "https://github.com/vrazdalovschi/pants-ty-plugin/issues"
+
+[tool.setuptools]
+package-dir = {"" = "pants-plugins"}
+
+[tool.setuptools.packages.find]
+where = ["pants-plugins"]
+include = ["pants_ty*"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+exclude = [".git", ".pants.d", "build", "dist"]

pants_ty-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+