typecheck-runner 0.1.2__py3-none-any.whl

typecheck_runner/__init__.py

@@ -0,0 +1,21 @@
+"""
+Top level API (:mod:`typecheck_runner`)
+=======================================
+"""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _version
+
+try:
+    __version__ = _version("typecheck-runner")
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "999"
+
+
+__author__ = """William P. Krekelberg"""
+__email__ = "wpk@nist.gov"
+
+
+__all__ = [
+    "__version__",
+]

typecheck_runner/__main__.py

@@ -0,0 +1,7 @@
+"""Make callable via `python -m typecheck_runner`"""
+
+from __future__ import annotations
+
+from typecheck_runner.typecheck_runner import main
+
+raise SystemExit(main())

typecheck_runner/typecheck_runner.py

@@ -0,0 +1,426 @@
+"""
+Interface to type checkers (mypy, (based)pyright, ty, pyrefly).
+
+This handles locating python-version and python-executable. This allows for
+running centrally installed (or via uvx) type checkers against a given virtual
+environment.
+"""
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+import logging
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from argparse import ArgumentParser
+from pathlib import Path
+from time import perf_counter
+from typing import TYPE_CHECKING
+
+from packaging.requirements import Requirement
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+    from logging import Logger
+
+
+FORMAT = "[typecheck-runner %(levelname)s] %(message)s"
+logger: Logger = logging.getLogger(__name__)
+
+
+# * Utilities -----------------------------------------------------------------
+def _setup_logging(
+    verbosity: int = 0,
+    stdout: bool = False,
+) -> None:  # pragma: no cover
+    """Setup logging."""
+    level_number = max(0, logging.WARNING - 10 * verbosity)
+    logger.setLevel(level_number)
+
+    # Silence noisy loggers
+    logging.getLogger("sh").setLevel(logging.WARNING)
+
+    if stdout:
+        handler = logging.StreamHandler(sys.stdout)
+        logging.basicConfig(level=logging.WARNING, format=FORMAT, handlers=[handler])
+    else:
+        logging.basicConfig(level=logging.WARNING, format=FORMAT)
+
+
+# * Runner --------------------------------------------------------------------
+
+
+def _infer_venv_location() -> Path:
+    for var in ("VIRTUAL_ENV", "CONDA_PREFIX"):
+        if venv := os.getenv(var, ""):
+            logger.debug("Inferred venv location %s", venv)
+            return Path(venv).absolute()
+
+    for d in (".venv",):
+        if (path := Path(d)).is_dir():
+            logger.debug("Inferred venv location %s", path)
+            return path.absolute()
+
+    msg = "Could not infer virtual environment"
+    raise ValueError(msg)
+
+
+def _get_python_executable_from_venv(
+    location: Path,
+) -> Path:
+    executable = "python.exe" if sys.platform.startswith("win") else "python"
+    for d in ("bin", "Scripts"):
+        if (path := location / d / executable).exists():
+            logger.debug("Inferred python-executable %s", path)
+            return path.absolute()
+
+    msg = f"No virtual environment found under {location}"
+    raise ValueError(msg)
+
+
+def _get_python_executable(
+    python_executable: Path | None, venv: Path | None, infer_venv: bool
+) -> Path | None:
+    if venv is None and infer_venv:
+        venv = _infer_venv_location()
+
+    if venv is not None:
+        return _get_python_executable_from_venv(venv)
+
+    return python_executable
+
+
+def _get_python_values(
+    python_version: str | None,
+    python_executable: Path | None,
+    no_python_version: bool,
+    no_python_executable: bool,
+) -> tuple[str | None, Path | None]:
+    if python_version is None and not no_python_version:
+        if python_executable is not None:
+            # infer python version from python_executable
+            logger.debug(
+                "Calculate python-version from executable %s", python_executable
+            )
+            script = "import sys; info = sys.version_info; print(f'{info.major}.{info.minor}')"
+            python_version = (
+                subprocess.check_output([python_executable, "-c", script])
+                .decode("utf-8")
+                .strip()
+            )
+        else:
+            python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+
+    if python_executable is None and not no_python_executable:
+        python_executable = Path(sys.executable)
+
+    return python_version, python_executable
+
+
+def _maybe_add_check_argument(checker: str, args: list[str]) -> list[str]:
+    if checker in {"ty", "pyrefly"} and "check" not in args:
+        return ["check", *args]
+    return args
+
+
+def _parse_command(
+    command: str,
+    no_uvx: bool,
+    uvx_delimiter: str,
+    uvx_options: Sequence[str],
+) -> tuple[str, list[str]]:
+    command, *args = shlex.split(command)
+
+    if no_uvx:
+        path = Path(command).expanduser()
+        checker = path.name
+        path_str = str(path)
+        return checker, [
+            shutil.which(path_str) or path_str,
+            *_maybe_add_check_argument(checker, args),
+        ]
+
+    req = Requirement(command)
+    checker = req.name
+
+    idx = args.index(uvx_delimiter) if uvx_delimiter in args else len(args)
+    checker_args = args[:idx]
+    uvx_args = args[idx + 1 :]
+
+    args = [
+        "uvx",
+        *uvx_options,
+        *uvx_args,
+        command,
+        *_maybe_add_check_argument(checker, checker_args),
+    ]
+    return checker, args
+
+
+PYRIGHT_LIKE_CHECKERS = {"pyright", "basedpyright"}
+
+
+def _get_python_flags(
+    checker: str,
+    python_version: str | None,
+    python_executable: str | Path | None,
+) -> list[str]:
+    out: list[str] = []
+    if python_version is not None:
+        version_flag = (
+            "pythonversion" if checker in PYRIGHT_LIKE_CHECKERS else "python-version"
+        )
+        out.append(f"--{version_flag}={python_version}")
+
+    if python_executable is not None:
+        if checker in PYRIGHT_LIKE_CHECKERS:
+            python_flag = "pythonpath"
+        elif checker == "ty":
+            python_flag = "python"
+        elif checker == "pyrefly":
+            python_flag = "python-interpreter-path"
+        elif checker == "mypy":
+            # default to mypy
+            python_flag = "python-executable"
+        else:
+            msg = f"Unknown checker {checker}"
+            raise ValueError(msg)
+        out.append(f"--{python_flag}={python_executable}")
+
+    return out
+
+
+def _run_checker(
+    *args: str,
+    dry_run: bool = False,
+) -> int:
+    cleaned_args = [os.fsdecode(arg) for arg in args]
+    full_cmd = shlex.join(cleaned_args)
+    logger.info("Command: %s", full_cmd)
+
+    if dry_run:
+        return 0
+
+    start_time = perf_counter()
+    returncode = subprocess.call(cleaned_args)
+    logger.info("Execution time: %s", perf_counter() - start_time)
+    if returncode:
+        logger.error("Failed with exit code: %s", returncode)
+
+    return returncode
+
+
+# * Application ---------------------------------------------------------------
+def get_parser() -> ArgumentParser:
+    """Get argparser."""
+    parser = ArgumentParser(description="Run executable using uvx.")
+    _ = parser.add_argument("--version", action="store_true", help="Display version.")
+
+    _ = parser.add_argument(
+        "-c",
+        "--check",
+        dest="checkers",
+        default=[],
+        action="append",
+        help="""
+        Checker to run. This can be a string with options to the checker. For
+        example, ``--check "mypy --verbose"`` runs the checker the command
+        ``mypy --verbose``. Options after ``uvx_delimiter`` (default ``"--"``,
+        see ``--uvx-delimiter`` options) are treated as ``uvx`` options. For
+        example, passing ``--check "mypy --verbose -- --reinstall"`` will run
+        ``uvx --reinstall mypy --verbose``. Can be specified multiple times.
+        """,
+    )
+    _ = parser.add_argument(
+        "--python-executable",
+        dest="python_executable",
+        default=None,
+        type=Path,
+        help="""
+        Path to python executable. Defaults to ``sys.executable``. This is
+        passed to ``--python-executable`` (mypy), ``--pythonpath`` in
+        ((based)pyright), ``--python`` (ty), ``--python-interpreter-path``
+        (pyrefly), and ignored for pylint.
+        """,
+    )
+    _ = parser.add_argument(
+        "--python-version",
+        dest="python_version",
+        default=None,
+        type=str,
+        help="""
+        Python version (x.y) to typecheck against. Defaults to
+        ``{sys.version_info.major}.{sys.version_info.minor}``. This is passed
+        to ``--pythonversion`` in pyright and ``--python-version`` otherwise.
+        """,
+    )
+    _ = parser.add_argument(
+        "--no-python-executable",
+        action="store_true",
+        help="""
+        Do not infer ``python_executable``
+        """,
+    )
+    _ = parser.add_argument(
+        "--no-python-version",
+        action="store_true",
+        help="""
+        Do not infer ``python_version``.
+        """,
+    )
+
+    _ = parser.add_argument(
+        "--venv",
+        type=Path,
+        help="""
+        Use specified vitualenvironment location
+        """,
+    )
+    _ = parser.add_argument(
+        "--infer-venv",
+        action="store_true",
+        help="""
+        Infer virtual environment location.  Checks in order environment variables ``VIRTUAL_ENV``, ``CONDA_PREFIX``, directory ``.venv``.
+        """,
+    )
+    _ = parser.add_argument(
+        "--constraints",
+        dest="constraints",
+        default=[],
+        action="append",
+        type=Path,
+        help="""
+        Constraints (requirements.txt) specs for checkers. Can specify multiple
+        times. Passed to ``uvx --constraints=...``.
+        """,
+    )
+    _ = parser.add_argument(
+        "-v",
+        "--verbose",
+        dest="verbosity",
+        action="count",
+        default=0,
+        help="Set verbosity level.  Pass multiple times to up level.",
+    )
+    _ = parser.add_argument(
+        "--stdout", action="store_true", help="logger information to stdout"
+    )
+    _ = parser.add_argument(
+        "--allow-errors",
+        action="store_true",
+        help="""
+        If passed, return ``0`` regardless of checker status.
+        """,
+    )
+    _ = parser.add_argument(
+        "--fail-fast",
+        action="store_true",
+        help="""
+        Exit on first failed checker. Default is to run all checkers, even if
+        they fail.
+        """,
+    )
+    _ = parser.add_argument(
+        "--dry-run", action="store_true", help="""Perform dry run."""
+    )
+    _ = parser.add_argument(
+        "--no-uvx",
+        dest="no_uvx",
+        action="store_true",
+        help="""
+        If ``--no-uvx`` is passed, assume typecheckers are in the current
+        python environment. Default is to invoke typecheckers using `uvx`.
+        """,
+    )
+    _ = parser.add_argument(
+        "--uvx-options",
+        default="",
+        help="""
+        Extra options to pass to ``uvx``. Note that you may have to escape the
+        first option. For example, ``--uvx-options "\\--verbose --reinstall"
+        """,
+    )
+    _ = parser.add_argument(
+        "--uvx-delimiter",
+        default="--",
+        help="""
+        Delimiter between typechecker command arguments and ``uvx`` arguments.
+        See ``--check`` option.
+        """,
+    )
+    _ = parser.add_argument(
+        "args",
+        type=str,
+        nargs="*",
+        default=[],
+        help="Extra files/arguments passed to all checkers.",
+    )
+
+    return parser
+
+
+def main(args: Sequence[str] | None = None) -> int:
+    """Main script."""
+    parser = get_parser()
+    options = parser.parse_args(args)
+
+    if options.version:
+        from typecheck_runner import __version__
+
+        print("typecheck-runner", __version__)  # noqa: T201
+        return 0
+
+    if not options.checkers:
+        parser.print_help()
+        return 2
+
+    _setup_logging(options.verbosity, options.stdout)
+
+    # possibly infer python executable from location
+    python_version, python_executable = _get_python_values(
+        python_version=options.python_version,
+        python_executable=_get_python_executable(
+            options.python_executable, options.venv, options.infer_venv
+        ),
+        no_python_version=options.no_python_version,
+        no_python_executable=options.no_python_executable,
+    )
+
+    logger.info("python_executable %s", python_executable)
+    logger.info("python_version %s", python_version)
+    logger.debug("checkers: %s", options.checkers)
+    logger.debug("args: %s", options.args)
+
+    uvx_options = [
+        *shlex.split(options.uvx_options),
+        *(f"--constraints={c}" for c in options.constraints),
+    ]
+
+    code = 0
+    for command in options.checkers:
+        checker, args = _parse_command(
+            command,
+            no_uvx=options.no_uvx,
+            uvx_delimiter=options.uvx_delimiter,
+            uvx_options=uvx_options,
+        )
+        logger.info("Checker: %s", checker)
+        checker_code = _run_checker(
+            *args,
+            *_get_python_flags(checker, python_version, python_executable),
+            *options.args,
+            dry_run=options.dry_run,
+        )
+        if options.fail_fast and checker_code:
+            return checker_code
+
+        code += checker_code
+
+    return 0 if options.allow_errors else code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

typecheck_runner-0.1.2.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: typecheck-runner
+Version: 0.1.2
+Summary: Unified api to multiple typecheckers
+Keywords: typecheck-runner
+Author: William P. Krekelberg
+Author-email: William P. Krekelberg <wpk@nist.gov>
+License-Expression: NIST-PD
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Dist: packaging>=25.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/wpk-nist-gov/typecheck-runner
+Description-Content-Type: text/markdown
+
+<!-- markdownlint-disable MD041 -->
+
+<!-- prettier-ignore-start -->
+[![Repo][repo-badge]][repo-link]
+[![PyPI license][license-badge]][license-link]
+[![PyPI version][pypi-badge]][pypi-link]
+[![Code style: ruff][ruff-badge]][ruff-link]
+[![uv][uv-badge]][uv-link]
+
+<!--
+  For more badges, see
+  https://shields.io/category/other
+  https://naereen.github.io/badges/
+  [pypi-badge]: https://badge.fury.io/py/typecheck-runner
+-->
+
+[ruff-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
+[ruff-link]: https://github.com/astral-sh/ruff
+[uv-badge]: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json
+[uv-link]: https://github.com/astral-sh/uv
+[pypi-badge]: https://img.shields.io/pypi/v/typecheck-runner
+[pypi-link]: https://pypi.org/project/typecheck-runner
+[repo-badge]: https://img.shields.io/badge/--181717?logo=github&logoColor=ffffff
+[repo-link]: https://github.com/wpk-nist-gov/typecheck-runner
+[license-badge]: https://img.shields.io/pypi/l/typecheck-runner?color=informational
+[license-link]: https://github.com/wpk-nist-gov/typecheck-runner/blob/main/LICENSE
+[changelog-link]: https://github.com/wpk-nist-gov/typecheck-runner/blob/main/CHANGELOG.md
+
+<!-- other links -->
+
+[mypy]: https://github.com/python/mypy
+[pyright]: https://github.com/microsoft/pyright
+[basedpyright]: https://github.com/DetachHead/basedpyright
+[ty]: https://github.com/astral-sh/ty
+[pyrefly]: https://github.com/microsoft/pyright
+<!-- [pre-commit]: https://pre-commit.com/ -->
+<!-- [prek]: https://github.com/j178/prek -->
+
+<!-- prettier-ignore-end -->
+
+# `typecheck-runner`
+
+A unified way to run globally installed typecheckers against a specified virtual
+environment.
+
+## Overview
+
+I prefer to invoke globally managed type checkers against specified virtual
+environments. For cases where python versions are checked against (with, for
+example tox or nox), this prevents each virtual environment from having to
+contain a type checker. Each type checker ([mypy], [pyright], [basedpyright],
+[ty], and [pyrefly]) has it's own particular flags to specify the python
+executable and the python version. `typecheck-runner` unifies these flags. Also,
+by default, `typecheck-runner` invokes the type checker using
+[`uvx`](https://docs.astral.sh/uv/guides/tools/), which installs the type
+checker if needed.
+
+## Usage
+
+### Install into virtual environment
+
+The easiest way to use `typecheck-runner` is to install it into the virtual
+environment you'd like to test against using something like
+
+```bash
+pip install typecheck-runner
+```
+
+from the virtual environment of interest. To invoke a type checker against the
+virtual environment, assuming the python executable of the virtual environment
+is located at `/path/to/venv/bin` with python version `3.13`, use
+
+```bash
+typecheck-runner --check mypy
+# runs: uvx mypy --python-version=3.13 --python-executable=/path/to/venv/bin
+```
+
+Where the commented line shows the command run. Specifying `--no-uvx` will
+instead invoke the type checker without `uvx`, so the type checker must already
+be installed.
+
+You can specify multiple checkers with multiple `--check` flags. To specify
+options to `uvx` for each checker, pass options after `--uvx-delimiter` which
+defaults to `--`. For example:
+
+```bash
+typecheck-runner --check "mypy --verbose -- --reinstall"
+# runs: uvx --reinstall mypy --verbose
+```
+
+You can specify `uvx` options to all checkers using the `--uvx-options` flag.
+
+### Specify virtual environment
+
+You can also use a globally installed `typecheck-runner` and specify which
+virtual environment to test over using `--venv` or `--infer-venv` options. For
+example, you can use:
+
+```bash
+uvx typecheck-runner --venv .venv --check mypy
+# run for example (if .venv current directory with version 3.14)
+#   uvx mypy --python-version=3.14 --python-executable=.venv/bin/python
+```
+
+Using `--infer-venv` will attempt to infer the virtual environment from, in
+order, environment variables `VIRTUAL_ENV`, `CONDA_PREFIX`, and finally `.venv`
+in current directory.
+
+## Options
+
+<!-- markdownlint-disable-next-line MD013 -->
+<!-- [[[cog
+import sys
+sys.path.insert(0, ".")
+from tools.cog_utils import wrap_command, get_pyproject, run_command, cat_lines
+sys.path.pop(0)
+]]] -->
+<!-- [[[end]]] -->
+
+<!-- prettier-ignore-start -->
+<!-- markdownlint-disable MD013 -->
+<!-- [[[cog run_command("typecheck-runner --help", include_cmd=False, wrapper="restructuredtext")]]] -->
+
+```restructuredtext
+usage: typecheck-runner [-h] [--version] [-c CHECKERS]
+                        [--python-executable PYTHON_EXECUTABLE]
+                        [--python-version PYTHON_VERSION] [--no-python-executable]
+                        [--no-python-version] [--venv VENV] [--infer-venv]
+                        [--constraints CONSTRAINTS] [-v] [--stdout] [--allow-errors]
+                        [--fail-fast] [--dry-run] [--no-uvx] [--uvx-options UVX_OPTIONS]
+                        [--uvx-delimiter UVX_DELIMITER]
+                        [args ...]
+
+Run executable using uvx.
+
+positional arguments:
+  args                  Extra files/arguments passed to all checkers.
+
+options:
+  -h, --help            show this help message and exit
+  --version             Display version.
+  -c, --check CHECKERS  Checker to run. This can be a string with options to the
+                        checker. For example, ``--check "mypy --verbose"`` runs the
+                        checker the command ``mypy --verbose``. Options after
+                        ``uvx_delimiter`` (default ``"--"``, see ``--uvx-delimiter``
+                        options) are treated as ``uvx`` options. For example, passing
+                        ``--check "mypy --verbose -- --reinstall"`` will run ``uvx
+                        --reinstall mypy --verbose``. Can be specified multiple times.
+  --python-executable PYTHON_EXECUTABLE
+                        Path to python executable. Defaults to ``sys.executable``. This
+                        is passed to ``--python-executable`` (mypy), ``--pythonpath`` in
+                        ((based)pyright), ``--python`` (ty), ``--python-interpreter-
+                        path`` (pyrefly), and ignored for pylint.
+  --python-version PYTHON_VERSION
+                        Python version (x.y) to typecheck against. Defaults to
+                        ``{sys.version_info.major}.{sys.version_info.minor}``. This is
+                        passed to ``--pythonversion`` in pyright and ``--python-
+                        version`` otherwise.
+  --no-python-executable
+                        Do not infer ``python_executable``
+  --no-python-version   Do not infer ``python_version``.
+  --venv VENV           Use specified vitualenvironment location
+  --infer-venv          Infer virtual environment location. Checks in order environment
+                        variables ``VIRTUAL_ENV``, ``CONDA_PREFIX``, directory
+                        ``.venv``.
+  --constraints CONSTRAINTS
+                        Constraints (requirements.txt) specs for checkers. Can specify
+                        multiple times. Passed to ``uvx --constraints=...``.
+  -v, --verbose         Set verbosity level. Pass multiple times to up level.
+  --stdout              logger information to stdout
+  --allow-errors        If passed, return ``0`` regardless of checker status.
+  --fail-fast           Exit on first failed checker. Default is to run all checkers,
+                        even if they fail.
+  --dry-run             Perform dry run.
+  --no-uvx              If ``--no-uvx`` is passed, assume typecheckers are in the
+                        current python environment. Default is to invoke typecheckers
+                        using `uvx`.
+  --uvx-options UVX_OPTIONS
+                        Extra options to pass to ``uvx``. Note that you may have to
+                        escape the first option. For example, ``--uvx-options
+                        "\--verbose --reinstall"
+  --uvx-delimiter UVX_DELIMITER
+                        Delimiter between typechecker command arguments and ``uvx``
+                        arguments. See ``--check`` option.
+```
+
+<!-- [[[end]]] -->
+<!-- prettier-ignore-end -->
+
+## Status
+
+This package is actively used by the author. Please feel free to create a pull
+request for wanted features and suggestions!
+
+<!-- end-docs -->
+
+## Installation
+
+<!-- start-installation -->
+
+Use one of the following
+
+```bash
+pip install typecheck-runner
+uv pip install typecheck-runner
+uv add typecheck-runner
+...
+```
+
+<!-- end-installation -->
+
+## What's new?
+
+See [changelog][changelog-link].
+
+## License
+
+This is free software. See [LICENSE][license-link].
+
+## Related work
+
+Any other stuff to mention....
+
+## Contact
+
+The author can be reached at <wpk@nist.gov>.
+
+## Credits
+
+This package was created using
+[Cookiecutter](https://github.com/audreyr/cookiecutter) with the
+[usnistgov/cookiecutter-nist-python](https://github.com/usnistgov/cookiecutter-nist-python)
+template.

typecheck_runner-0.1.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+typecheck_runner/__init__.py,sha256=bN5LuK_PNk5YFr2rdgX1CwJWHRMtspp30M1SHd2uhbE,423
+typecheck_runner/__main__.py,sha256=rRzOwUCzMPhYnn4hruIKPM_vSOddm9rCZ6dF5SW4_m0,167
+typecheck_runner/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+typecheck_runner/typecheck_runner.py,sha256=o21akaFiaacdkki2dRbZ7fdTvZ2hqIUzEd1Yg2JmNF8,12588
+typecheck_runner-0.1.2.dist-info/licenses/LICENSE,sha256=j_sUyRmuUbF_c9KR7g_uTdRv-cBn65wjYQpmusAzyT0,1645
+typecheck_runner-0.1.2.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+typecheck_runner-0.1.2.dist-info/entry_points.txt,sha256=DnC_eOsN1KeMB9CKwGKR4DJ7vcbAExz1JlNBy1x9PPE,77
+typecheck_runner-0.1.2.dist-info/METADATA,sha256=wU2JMhkwg1oECleZwgSm_mJpVs3JUk-9hi7_8kRsSmM,10094
+typecheck_runner-0.1.2.dist-info/RECORD,,

typecheck_runner-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any

typecheck_runner-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+typecheck-runner = typecheck_runner.typecheck_runner:main
+

typecheck_runner-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+This software was developed by employees of the National Institute of Standards
+and Technology (NIST), an agency of the Federal Government. Pursuant to title 17
+United States Code Section 105, works of NIST employees are not subject to
+copyright protection in the United States and are considered to be in the public
+domain. Permission to freely use, copy, modify, and distribute this software and
+its documentation without fee is hereby granted, provided that this notice and
+disclaimer of warranty appears in all copies.
+
+THE SOFTWARE IS PROVIDED 'AS IS' WITHOUT ANY WARRANTY OF ANY KIND, EITHER
+EXPRESSED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY
+THAT THE SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND FREEDOM FROM
+INFRINGEMENT, AND ANY WARRANTY THAT THE DOCUMENTATION WILL CONFORM TO THE
+SOFTWARE, OR ANY WARRANTY THAT THE SOFTWARE WILL BE ERROR FREE. IN NO EVENT
+SHALL NIST BE LIABLE FOR ANY DAMAGES, INCLUDING, BUT NOT LIMITED TO, DIRECT,
+INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES, ARISING OUT OF, RESULTING FROM, OR
+IN ANY WAY CONNECTED WITH THIS SOFTWARE, WHETHER OR NOT BASED UPON WARRANTY,
+CONTRACT, TORT, OR OTHERWISE, WHETHER OR NOT INJURY WAS SUSTAINED BY PERSONS OR
+PROPERTY OR OTHERWISE, AND WHETHER OR NOT LOSS WAS SUSTAINED FROM, OR AROSE OUT
+OF THE RESULTS OF, OR USE OF, THE SOFTWARE OR SERVICES PROVIDED HEREUNDER.
+
+Distributions of NIST software should also include copyright and licensing
+statements of any third-party software that are legally bundled with the code in
+compliance with the conditions of those licenses.