pre-commit-ex 4.5.1__py2.py3-none-any.whl

pre_commit/languages/pygrep.py

@@ -0,0 +1,133 @@
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from collections.abc import Sequence
+from re import Pattern
+from typing import NamedTuple
+
+from pre_commit import lang_base
+from pre_commit import output
+from pre_commit.prefix import Prefix
+from pre_commit.xargs import xargs
+
+ENVIRONMENT_DIR = None
+get_default_version = lang_base.basic_get_default_version
+health_check = lang_base.basic_health_check
+install_environment = lang_base.no_install
+in_env = lang_base.no_env
+
+
+def _process_filename_by_line(pattern: Pattern[bytes], filename: str) -> int:
+    retv = 0
+    with open(filename, 'rb') as f:
+        for line_no, line in enumerate(f, start=1):
+            if pattern.search(line):
+                retv = 1
+                output.write(f'{filename}:{line_no}:')
+                output.write_line_b(line.rstrip(b'\r\n'))
+    return retv
+
+
+def _process_filename_at_once(pattern: Pattern[bytes], filename: str) -> int:
+    retv = 0
+    with open(filename, 'rb') as f:
+        contents = f.read()
+        match = pattern.search(contents)
+        if match:
+            retv = 1
+            line_no = contents[:match.start()].count(b'\n')
+            output.write(f'{filename}:{line_no + 1}:')
+
+            matched_lines = match[0].split(b'\n')
+            matched_lines[0] = contents.split(b'\n')[line_no]
+
+            output.write_line_b(b'\n'.join(matched_lines))
+    return retv
+
+
+def _process_filename_by_line_negated(
+        pattern: Pattern[bytes],
+        filename: str,
+) -> int:
+    with open(filename, 'rb') as f:
+        for line in f:
+            if pattern.search(line):
+                return 0
+        else:
+            output.write_line(filename)
+            return 1
+
+
+def _process_filename_at_once_negated(
+        pattern: Pattern[bytes],
+        filename: str,
+) -> int:
+    with open(filename, 'rb') as f:
+        contents = f.read()
+    match = pattern.search(contents)
+    if match:
+        return 0
+    else:
+        output.write_line(filename)
+        return 1
+
+
+class Choice(NamedTuple):
+    multiline: bool
+    negate: bool
+
+
+FNS = {
+    Choice(multiline=True, negate=True): _process_filename_at_once_negated,
+    Choice(multiline=True, negate=False): _process_filename_at_once,
+    Choice(multiline=False, negate=True): _process_filename_by_line_negated,
+    Choice(multiline=False, negate=False): _process_filename_by_line,
+}
+
+
+def run_hook(
+        prefix: Prefix,
+        entry: str,
+        args: Sequence[str],
+        file_args: Sequence[str],
+        *,
+        is_local: bool,
+        require_serial: bool,
+        color: bool,
+) -> tuple[int, bytes]:
+    cmd = (sys.executable, '-m', __name__, *args, entry)
+    return xargs(cmd, file_args, color=color)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description=(
+            'grep-like finder using python regexes.  Unlike grep, this tool '
+            'returns nonzero when it finds a match and zero otherwise.  The '
+            'idea here being that matches are "problems".'
+        ),
+    )
+    parser.add_argument('-i', '--ignore-case', action='store_true')
+    parser.add_argument('--multiline', action='store_true')
+    parser.add_argument('--negate', action='store_true')
+    parser.add_argument('pattern', help='python regex pattern.')
+    parser.add_argument('filenames', nargs='*')
+    args = parser.parse_args(argv)
+
+    flags = re.IGNORECASE if args.ignore_case else 0
+    if args.multiline:
+        flags |= re.MULTILINE | re.DOTALL
+
+    pattern = re.compile(args.pattern.encode(), flags)
+
+    retv = 0
+    process_fn = FNS[Choice(multiline=args.multiline, negate=args.negate)]
+    for filename in args.filenames:
+        retv |= process_fn(pattern, filename)
+    return retv
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

pre_commit/languages/python.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import contextlib
+import functools
+import os
+import sys
+from collections.abc import Generator
+from collections.abc import Sequence
+
+import pre_commit.constants as C
+from pre_commit import lang_base
+from pre_commit.envcontext import envcontext
+from pre_commit.envcontext import PatchesT
+from pre_commit.envcontext import UNSET
+from pre_commit.envcontext import Var
+from pre_commit.parse_shebang import find_executable
+from pre_commit.prefix import Prefix
+from pre_commit.util import CalledProcessError
+from pre_commit.util import cmd_output
+from pre_commit.util import cmd_output_b
+from pre_commit.util import win_exe
+
+ENVIRONMENT_DIR = 'py_env'
+run_hook = lang_base.basic_run_hook
+
+
+@functools.cache
+def _version_info(exe: str) -> str:
+    prog = 'import sys;print(".".join(str(p) for p in sys.version_info))'
+    try:
+        return cmd_output(exe, '-S', '-c', prog)[1].strip()
+    except CalledProcessError:
+        return f'<<error retrieving version from {exe}>>'
+
+
+def _read_pyvenv_cfg(filename: str) -> dict[str, str]:
+    ret = {}
+    with open(filename, encoding='UTF-8') as f:
+        for line in f:
+            try:
+                k, v = line.split('=')
+            except ValueError:  # blank line / comment / etc.
+                continue
+            else:
+                ret[k.strip()] = v.strip()
+    return ret
+
+
+def bin_dir(venv: str) -> str:
+    """On windows there's a different directory for the virtualenv"""
+    bin_part = 'Scripts' if sys.platform == 'win32' else 'bin'
+    return os.path.join(venv, bin_part)
+
+
+def get_env_patch(venv: str) -> PatchesT:
+    return (
+        ('PIP_DISABLE_PIP_VERSION_CHECK', '1'),
+        ('PYTHONHOME', UNSET),
+        ('VIRTUAL_ENV', venv),
+        ('PATH', (bin_dir(venv), os.pathsep, Var('PATH'))),
+    )
+
+
+def _find_by_py_launcher(
+        version: str,
+) -> str | None:  # pragma: no cover (windows only)
+    if version.startswith('python'):
+        num = version.removeprefix('python')
+        cmd = ('py', f'-{num}', '-c', 'import sys; print(sys.executable)')
+        env = dict(os.environ, PYTHONIOENCODING='UTF-8')
+        try:
+            return cmd_output(*cmd, env=env)[1].strip()
+        except CalledProcessError:
+            pass
+    return None
+
+
+def _impl_exe_name() -> str:
+    if sys.implementation.name == 'cpython':  # pragma: cpython cover
+        return 'python'
+    else:  # pragma: cpython no cover
+        return sys.implementation.name  # pypy mostly
+
+
+def _find_by_sys_executable() -> str | None:
+    def _norm(path: str) -> str | None:
+        _, exe = os.path.split(path.lower())
+        exe, _, _ = exe.partition('.exe')
+        if exe not in {'python', 'pythonw'} and find_executable(exe):
+            return exe
+        return None
+
+    # On linux, I see these common sys.executables:
+    #
+    # system `python`: /usr/bin/python -> python2.7
+    # system `python2`: /usr/bin/python2 -> python2.7
+    # virtualenv v: v/bin/python (will not return from this loop)
+    # virtualenv v -ppython2: v/bin/python -> python2
+    # virtualenv v -ppython2.7: v/bin/python -> python2.7
+    # virtualenv v -ppypy: v/bin/python -> v/bin/pypy
+    for path in (sys.executable, os.path.realpath(sys.executable)):
+        exe = _norm(path)
+        if exe:
+            return exe
+    return None
+
+
+@functools.lru_cache(maxsize=1)
+def get_default_version() -> str:  # pragma: no cover (platform dependent)
+    v_major = f'{sys.version_info[0]}'
+    v_minor = f'{sys.version_info[0]}.{sys.version_info[1]}'
+
+    # attempt the likely implementation exe
+    for potential in (v_minor, v_major):
+        exe = f'{_impl_exe_name()}{potential}'
+        if find_executable(exe):
+            return exe
+
+    # next try `sys.executable` (or the realpath)
+    maybe_exe = _find_by_sys_executable()
+    if maybe_exe:
+        return maybe_exe
+
+    # maybe on windows we can find it via py launcher?
+    if sys.platform == 'win32':  # pragma: win32 cover
+        exe = f'python{v_minor}'
+        if _find_by_py_launcher(exe):
+            return exe
+
+    # We tried!
+    return C.DEFAULT
+
+
+def _sys_executable_matches(version: str) -> bool:
+    if version == 'python':
+        return True
+    elif not version.startswith('python'):
+        return False
+
+    try:
+        info = tuple(int(p) for p in version.removeprefix('python').split('.'))
+    except ValueError:
+        return False
+
+    return sys.version_info[:len(info)] == info
+
+
+def norm_version(version: str) -> str | None:
+    if version == C.DEFAULT:  # use virtualenv's default
+        return None
+    elif _sys_executable_matches(version):  # virtualenv defaults to our exe
+        return None
+
+    if sys.platform == 'win32':  # pragma: no cover (windows)
+        version_exec = _find_by_py_launcher(version)
+        if version_exec:
+            return version_exec
+
+        # Try looking up by name
+        version_exec = find_executable(version)
+        if version_exec and version_exec != version:
+            return version_exec
+
+    # Otherwise assume it is a path
+    return os.path.expanduser(version)
+
+
+@contextlib.contextmanager
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    with envcontext(get_env_patch(envdir)):
+        yield
+
+
+def health_check(prefix: Prefix, version: str) -> str | None:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    pyvenv_cfg = os.path.join(envdir, 'pyvenv.cfg')
+
+    # created with "old" virtualenv
+    if not os.path.exists(pyvenv_cfg):
+        return 'pyvenv.cfg does not exist (old virtualenv?)'
+
+    exe_name = win_exe('python')
+    py_exe = prefix.path(bin_dir(envdir), exe_name)
+    cfg = _read_pyvenv_cfg(pyvenv_cfg)
+
+    if 'version_info' not in cfg:
+        return "created virtualenv's pyvenv.cfg is missing `version_info`"
+
+    # always use uncached lookup here in case we replaced an unhealthy env
+    virtualenv_version = _version_info.__wrapped__(py_exe)
+    if virtualenv_version != cfg['version_info']:
+        return (
+            f'virtualenv python version did not match created version:\n'
+            f'- actual version: {virtualenv_version}\n'
+            f'- expected version: {cfg["version_info"]}\n'
+        )
+
+    # made with an older version of virtualenv? skip `base-executable` check
+    if 'base-executable' not in cfg:
+        return None
+
+    base_exe_version = _version_info(cfg['base-executable'])
+    if base_exe_version != cfg['version_info']:
+        return (
+            f'base executable python version does not match created version:\n'
+            f'- base-executable version: {base_exe_version}\n'
+            f'- expected version: {cfg["version_info"]}\n'
+        )
+    else:
+        return None
+
+
+def install_environment(
+        prefix: Prefix,
+        version: str,
+        additional_dependencies: Sequence[str],
+) -> None:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    venv_cmd = [sys.executable, '-mvirtualenv', envdir]
+    python = norm_version(version)
+    if python is not None:
+        venv_cmd.extend(('-p', python))
+    install_cmd = ('python', '-mpip', 'install', '.', *additional_dependencies)
+
+    cmd_output_b(*venv_cmd, cwd='/')
+    with in_env(prefix, version):
+        lang_base.setup_cmd(prefix, install_cmd)

pre_commit/languages/r.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import shlex
+import shutil
+import tempfile
+import textwrap
+from collections.abc import Generator
+from collections.abc import Sequence
+
+from pre_commit import lang_base
+from pre_commit.envcontext import envcontext
+from pre_commit.envcontext import PatchesT
+from pre_commit.envcontext import UNSET
+from pre_commit.prefix import Prefix
+from pre_commit.util import cmd_output
+from pre_commit.util import win_exe
+
+ENVIRONMENT_DIR = 'renv'
+get_default_version = lang_base.basic_get_default_version
+
+_RENV_ACTIVATED_OPTS = (
+    '--no-save', '--no-restore', '--no-site-file', '--no-environ',
+)
+
+
+def _execute_r(
+        code: str, *,
+        prefix: Prefix, version: str, args: Sequence[str] = (), cwd: str,
+        cli_opts: Sequence[str],
+) -> str:
+    with in_env(prefix, version), _r_code_in_tempfile(code) as f:
+        _, out, _ = cmd_output(
+            _rscript_exec(), *cli_opts, f, *args, cwd=cwd,
+        )
+    return out.rstrip('\n')
+
+
+def _execute_r_in_renv(
+        code: str, *,
+        prefix: Prefix, version: str, args: Sequence[str] = (), cwd: str,
+) -> str:
+    return _execute_r(
+        code=code, prefix=prefix, version=version, args=args, cwd=cwd,
+        cli_opts=_RENV_ACTIVATED_OPTS,
+    )
+
+
+def _execute_vanilla_r(
+        code: str, *,
+        prefix: Prefix, version: str, args: Sequence[str] = (), cwd: str,
+) -> str:
+    return _execute_r(
+        code=code, prefix=prefix, version=version, args=args, cwd=cwd,
+        cli_opts=('--vanilla',),
+    )
+
+
+def _read_installed_version(envdir: str, prefix: Prefix, version: str) -> str:
+    return _execute_r_in_renv(
+        'cat(renv::settings$r.version())',
+        prefix=prefix, version=version,
+        cwd=envdir,
+    )
+
+
+def _read_executable_version(envdir: str, prefix: Prefix, version: str) -> str:
+    return _execute_r_in_renv(
+        'cat(as.character(getRversion()))',
+        prefix=prefix, version=version,
+        cwd=envdir,
+    )
+
+
+def _write_current_r_version(
+        envdir: str, prefix: Prefix, version: str,
+) -> None:
+    _execute_r_in_renv(
+        'renv::settings$r.version(as.character(getRversion()))',
+        prefix=prefix, version=version,
+        cwd=envdir,
+    )
+
+
+def health_check(prefix: Prefix, version: str) -> str | None:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+
+    r_version_installation = _read_installed_version(
+        envdir=envdir, prefix=prefix, version=version,
+    )
+    r_version_current_executable = _read_executable_version(
+        envdir=envdir, prefix=prefix, version=version,
+    )
+    if r_version_installation in {'NULL', ''}:
+        return (
+            f'Hooks were installed with an unknown R version. R version for '
+            f'hook repo now set to {r_version_current_executable}'
+        )
+    elif r_version_installation != r_version_current_executable:
+        return (
+            f'Hooks were installed for R version {r_version_installation}, '
+            f'but current R executable has version '
+            f'{r_version_current_executable}'
+        )
+
+    return None
+
+
+@contextlib.contextmanager
+def _r_code_in_tempfile(code: str) -> Generator[str]:
+    """
+    To avoid quoting and escaping issues, avoid `Rscript [options] -e {expr}`
+    but use `Rscript [options] path/to/file_with_expr.R`
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        fname = os.path.join(tmpdir, 'script.R')
+        with open(fname, 'w') as f:
+            f.write(_inline_r_setup(textwrap.dedent(code)))
+        yield fname
+
+
+def get_env_patch(venv: str) -> PatchesT:
+    return (
+        ('R_PROFILE_USER', os.path.join(venv, 'activate.R')),
+        ('RENV_PROJECT', UNSET),
+    )
+
+
+@contextlib.contextmanager
+def in_env(prefix: Prefix, version: str) -> Generator[None]:
+    envdir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    with envcontext(get_env_patch(envdir)):
+        yield
+
+
+def _prefix_if_file_entry(
+        entry: list[str],
+        prefix: Prefix,
+        *,
+        is_local: bool,
+) -> Sequence[str]:
+    if entry[1] == '-e' or is_local:
+        return entry[1:]
+    else:
+        return (prefix.path(entry[1]),)
+
+
+def _rscript_exec() -> str:
+    r_home = os.environ.get('R_HOME')
+    if r_home is None:
+        return 'Rscript'
+    else:
+        return os.path.join(r_home, 'bin', win_exe('Rscript'))
+
+
+def _entry_validate(entry: list[str]) -> None:
+    """
+    Allowed entries:
+    # Rscript -e expr
+    # Rscript path/to/file
+    """
+    if entry[0] != 'Rscript':
+        raise ValueError('entry must start with `Rscript`.')
+
+    if entry[1] == '-e':
+        if len(entry) > 3:
+            raise ValueError('You can supply at most one expression.')
+    elif len(entry) > 2:
+        raise ValueError(
+            'The only valid syntax is `Rscript -e {expr}`'
+            'or `Rscript path/to/hook/script`',
+        )
+
+
+def _cmd_from_hook(
+        prefix: Prefix,
+        entry: str,
+        args: Sequence[str],
+        *,
+        is_local: bool,
+) -> tuple[str, ...]:
+    cmd = shlex.split(entry)
+    _entry_validate(cmd)
+
+    cmd_part = _prefix_if_file_entry(cmd, prefix, is_local=is_local)
+    return (cmd[0], *_RENV_ACTIVATED_OPTS, *cmd_part, *args)
+
+
+def install_environment(
+        prefix: Prefix,
+        version: str,
+        additional_dependencies: Sequence[str],
+) -> None:
+    lang_base.assert_version_default('r', version)
+
+    env_dir = lang_base.environment_dir(prefix, ENVIRONMENT_DIR, version)
+    os.makedirs(env_dir, exist_ok=True)
+    shutil.copy(prefix.path('renv.lock'), env_dir)
+    shutil.copytree(prefix.path('renv'), os.path.join(env_dir, 'renv'))
+
+    r_code_inst_environment = f"""\
+        prefix_dir <- {prefix.prefix_dir!r}
+        options(
+            repos = c(CRAN = "https://cran.rstudio.com"),
+            renv.consent = TRUE
+        )
+        source("renv/activate.R")
+        renv::restore()
+        activate_statement <- paste0(
+          'suppressWarnings({{',
+          'old <- setwd("', getwd(), '"); ',
+          'source("renv/activate.R"); ',
+          'setwd(old); ',
+          'renv::load("', getwd(), '");}})'
+        )
+        writeLines(activate_statement, 'activate.R')
+        is_package <- tryCatch(
+          {{
+              path_desc <- file.path(prefix_dir, 'DESCRIPTION')
+              suppressWarnings(desc <- read.dcf(path_desc))
+              "Package" %in% colnames(desc)
+          }},
+          error = function(...) FALSE
+        )
+        if (is_package) {{
+            renv::install(prefix_dir)
+        }}
+        """
+    _execute_vanilla_r(
+        r_code_inst_environment,
+        prefix=prefix, version=version, cwd=env_dir,
+    )
+
+    _write_current_r_version(envdir=env_dir, prefix=prefix, version=version)
+    if additional_dependencies:
+        r_code_inst_add = 'renv::install(commandArgs(trailingOnly = TRUE))'
+        _execute_r_in_renv(
+            code=r_code_inst_add, prefix=prefix, version=version,
+            args=additional_dependencies,
+            cwd=env_dir,
+        )
+
+
+def _inline_r_setup(code: str) -> str:
+    """
+    Some behaviour of R cannot be configured via env variables, but can
+    only be configured via R options once R has started. These are set here.
+    """
+    with_option = [
+        textwrap.dedent("""\
+        options(
+            install.packages.compile.from.source = "never",
+            pkgType = "binary"
+        )
+        """),
+        code,
+    ]
+    return '\n'.join(with_option)
+
+
+def run_hook(
+        prefix: Prefix,
+        entry: str,
+        args: Sequence[str],
+        file_args: Sequence[str],
+        *,
+        is_local: bool,
+        require_serial: bool,
+        color: bool,
+) -> tuple[int, bytes]:
+    cmd = _cmd_from_hook(prefix, entry, args, is_local=is_local)
+    return lang_base.run_xargs(
+        cmd,
+        file_args,
+        require_serial=require_serial,
+        color=color,
+    )