We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
BUG - hooks not working on windows 10, when user account name contains non-ascii characters
When user account name contains non-ascii characters such as 'š', such that python executable ends up for example in C:\Users\john.š\\.cache\pre-commit\repo\py_env-python3.8\Scripts\python.exe, when committing to the git repository following message appears:

An unexpected error has occurred: AssertionError: BUG: expected environment for python to be healthy() immediately after install, please open an issue describing your environment.

PS: fucntion os.path.isfile() in parse_shebang.normexe() returns False, even though the executable exists there and is a file.

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `pre_commit/languages/python.py`
Content:
```
1 import contextlib
2 import functools
3 import os
4 import sys
5 from typing import Dict
6 from typing import Generator
7 from typing import Optional
8 from typing import Sequence
9 from typing import Tuple
10 
11 import pre_commit.constants as C
12 from pre_commit.envcontext import envcontext
13 from pre_commit.envcontext import PatchesT
14 from pre_commit.envcontext import UNSET
15 from pre_commit.envcontext import Var
16 from pre_commit.hook import Hook
17 from pre_commit.languages import helpers
18 from pre_commit.parse_shebang import find_executable
19 from pre_commit.prefix import Prefix
20 from pre_commit.util import CalledProcessError
21 from pre_commit.util import clean_path_on_failure
22 from pre_commit.util import cmd_output
23 from pre_commit.util import cmd_output_b
24 
25 ENVIRONMENT_DIR = 'py_env'
26 
27 
28 @functools.lru_cache(maxsize=None)
29 def _version_info(exe: str) -> str:
30     prog = 'import sys;print(".".join(str(p) for p in sys.version_info))'
31     try:
32         return cmd_output(exe, '-S', '-c', prog)[1].strip()
33     except CalledProcessError:
34         return f'<<error retrieving version from {exe}>>'
35 
36 
37 def _read_pyvenv_cfg(filename: str) -> Dict[str, str]:
38     ret = {}
39     with open(filename) as f:
40         for line in f:
41             try:
42                 k, v = line.split('=')
43             except ValueError:  # blank line / comment / etc.
44                 continue
45             else:
46                 ret[k.strip()] = v.strip()
47     return ret
48 
49 
50 def bin_dir(venv: str) -> str:
51     """On windows there's a different directory for the virtualenv"""
52     bin_part = 'Scripts' if os.name == 'nt' else 'bin'
53     return os.path.join(venv, bin_part)
54 
55 
56 def get_env_patch(venv: str) -> PatchesT:
57     return (
58         ('PIP_DISABLE_PIP_VERSION_CHECK', '1'),
59         ('PYTHONHOME', UNSET),
60         ('VIRTUAL_ENV', venv),
61         ('PATH', (bin_dir(venv), os.pathsep, Var('PATH'))),
62     )
63 
64 
65 def _find_by_py_launcher(
66         version: str,
67 ) -> Optional[str]:  # pragma: no cover (windows only)
68     if version.startswith('python'):
69         num = version[len('python'):]
70         cmd = ('py', f'-{num}', '-c', 'import sys; print(sys.executable)')
71         env = dict(os.environ, PYTHONIOENCODING='UTF-8')
72         try:
73             return cmd_output(*cmd, env=env)[1].strip()
74         except CalledProcessError:
75             pass
76     return None
77 
78 
79 def _find_by_sys_executable() -> Optional[str]:
80     def _norm(path: str) -> Optional[str]:
81         _, exe = os.path.split(path.lower())
82         exe, _, _ = exe.partition('.exe')
83         if exe not in {'python', 'pythonw'} and find_executable(exe):
84             return exe
85         return None
86 
87     # On linux, I see these common sys.executables:
88     #
89     # system `python`: /usr/bin/python -> python2.7
90     # system `python2`: /usr/bin/python2 -> python2.7
91     # virtualenv v: v/bin/python (will not return from this loop)
92     # virtualenv v -ppython2: v/bin/python -> python2
93     # virtualenv v -ppython2.7: v/bin/python -> python2.7
94     # virtualenv v -ppypy: v/bin/python -> v/bin/pypy
95     for path in (sys.executable, os.path.realpath(sys.executable)):
96         exe = _norm(path)
97         if exe:
98             return exe
99     return None
100 
101 
102 @functools.lru_cache(maxsize=1)
103 def get_default_version() -> str:  # pragma: no cover (platform dependent)
104     # First attempt from `sys.executable` (or the realpath)
105     exe = _find_by_sys_executable()
106     if exe:
107         return exe
108 
109     # Next try the `pythonX.X` executable
110     exe = f'python{sys.version_info[0]}.{sys.version_info[1]}'
111     if find_executable(exe):
112         return exe
113 
114     if _find_by_py_launcher(exe):
115         return exe
116 
117     # We tried!
118     return C.DEFAULT
119 
120 
121 def _sys_executable_matches(version: str) -> bool:
122     if version == 'python':
123         return True
124     elif not version.startswith('python'):
125         return False
126 
127     try:
128         info = tuple(int(p) for p in version[len('python'):].split('.'))
129     except ValueError:
130         return False
131 
132     return sys.version_info[:len(info)] == info
133 
134 
135 def norm_version(version: str) -> Optional[str]:
136     if version == C.DEFAULT:  # use virtualenv's default
137         return None
138     elif _sys_executable_matches(version):  # virtualenv defaults to our exe
139         return None
140 
141     if os.name == 'nt':  # pragma: no cover (windows)
142         version_exec = _find_by_py_launcher(version)
143         if version_exec:
144             return version_exec
145 
146         # Try looking up by name
147         version_exec = find_executable(version)
148         if version_exec and version_exec != version:
149             return version_exec
150 
151     # Otherwise assume it is a path
152     return os.path.expanduser(version)
153 
154 
155 @contextlib.contextmanager
156 def in_env(
157         prefix: Prefix,
158         language_version: str,
159 ) -> Generator[None, None, None]:
160     directory = helpers.environment_dir(ENVIRONMENT_DIR, language_version)
161     envdir = prefix.path(directory)
162     with envcontext(get_env_patch(envdir)):
163         yield
164 
165 
166 def healthy(prefix: Prefix, language_version: str) -> bool:
167     directory = helpers.environment_dir(ENVIRONMENT_DIR, language_version)
168     envdir = prefix.path(directory)
169     pyvenv_cfg = os.path.join(envdir, 'pyvenv.cfg')
170 
171     # created with "old" virtualenv
172     if not os.path.exists(pyvenv_cfg):
173         return False
174 
175     exe_name = 'python.exe' if sys.platform == 'win32' else 'python'
176     py_exe = prefix.path(bin_dir(envdir), exe_name)
177     cfg = _read_pyvenv_cfg(pyvenv_cfg)
178 
179     return (
180         'version_info' in cfg and
181         # always use uncached lookup here in case we replaced an unhealthy env
182         _version_info.__wrapped__(py_exe) == cfg['version_info'] and (
183             'base-executable' not in cfg or
184             _version_info(cfg['base-executable']) == cfg['version_info']
185         )
186     )
187 
188 
189 def install_environment(
190         prefix: Prefix,
191         version: str,
192         additional_dependencies: Sequence[str],
193 ) -> None:
194     envdir = prefix.path(helpers.environment_dir(ENVIRONMENT_DIR, version))
195     venv_cmd = [sys.executable, '-mvirtualenv', envdir]
196     python = norm_version(version)
197     if python is not None:
198         venv_cmd.extend(('-p', python))
199     install_cmd = ('python', '-mpip', 'install', '.', *additional_dependencies)
200 
201     with clean_path_on_failure(envdir):
202         cmd_output_b(*venv_cmd, cwd='/')
203         with in_env(prefix, version):
204             helpers.run_setup_cmd(prefix, install_cmd)
205 
206 
207 def run_hook(
208         hook: Hook,
209         file_args: Sequence[str],
210         color: bool,
211 ) -> Tuple[int, bytes]:
212     with in_env(hook.prefix, hook.language_version):
213         return helpers.run_xargs(hook, hook.cmd, file_args, color=color)
214
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/pre_commit/languages/python.py b/pre_commit/languages/python.py
--- a/pre_commit/languages/python.py
+++ b/pre_commit/languages/python.py
@@ -36,7 +36,7 @@
 
 def _read_pyvenv_cfg(filename: str) -> Dict[str, str]:
     ret = {}
-    with open(filename) as f:
+    with open(filename, encoding='UTF-8') as f:
         for line in f:
             try:
                 k, v = line.split('=')

{"golden_diff": "diff --git a/pre_commit/languages/python.py b/pre_commit/languages/python.py\n--- a/pre_commit/languages/python.py\n+++ b/pre_commit/languages/python.py\n@@ -36,7 +36,7 @@\n \n def _read_pyvenv_cfg(filename: str) -> Dict[str, str]:\n     ret = {}\n-    with open(filename) as f:\n+    with open(filename, encoding='UTF-8') as f:\n         for line in f:\n             try:\n                 k, v = line.split('=')\n", "issue": "BUG - hooks not working on windows 10, when user account name contains non-ascii characters\nWhen user account name contains non-ascii characters such as '\u0161', such that python executable ends up for example in C:\\Users\\john.\u0161\\\\.cache\\pre-commit\\repo\\py_env-python3.8\\Scripts\\python.exe, when committing to the git repository following message appears:\r\n\r\nAn unexpected error has occurred: AssertionError: BUG: expected environment for python to be healthy() immediately after install, please open an issue describing your environment.\r\n\r\nPS: fucntion os.path.isfile() in parse_shebang.normexe() returns False, even though the executable exists there and is a file.\n", "before_files": [{"content": "import contextlib\nimport functools\nimport os\nimport sys\nfrom typing import Dict\nfrom typing import Generator\nfrom typing import Optional\nfrom typing import Sequence\nfrom typing import Tuple\n\nimport pre_commit.constants as C\nfrom pre_commit.envcontext import envcontext\nfrom pre_commit.envcontext import PatchesT\nfrom pre_commit.envcontext import UNSET\nfrom pre_commit.envcontext import Var\nfrom pre_commit.hook import Hook\nfrom pre_commit.languages import helpers\nfrom pre_commit.parse_shebang import find_executable\nfrom pre_commit.prefix import Prefix\nfrom pre_commit.util import CalledProcessError\nfrom pre_commit.util import clean_path_on_failure\nfrom pre_commit.util import cmd_output\nfrom pre_commit.util import cmd_output_b\n\nENVIRONMENT_DIR = 'py_env'\n\n\n@functools.lru_cache(maxsize=None)\ndef _version_info(exe: str) -> str:\n    prog = 'import sys;print(\".\".join(str(p) for p in sys.version_info))'\n    try:\n        return cmd_output(exe, '-S', '-c', prog)[1].strip()\n    except CalledProcessError:\n        return f'<<error retrieving version from {exe}>>'\n\n\ndef _read_pyvenv_cfg(filename: str) -> Dict[str, str]:\n    ret = {}\n    with open(filename) as f:\n        for line in f:\n            try:\n                k, v = line.split('=')\n            except ValueError:  # blank line / comment / etc.\n                continue\n            else:\n                ret[k.strip()] = v.strip()\n    return ret\n\n\ndef bin_dir(venv: str) -> str:\n    \"\"\"On windows there's a different directory for the virtualenv\"\"\"\n    bin_part = 'Scripts' if os.name == 'nt' else 'bin'\n    return os.path.join(venv, bin_part)\n\n\ndef get_env_patch(venv: str) -> PatchesT:\n    return (\n        ('PIP_DISABLE_PIP_VERSION_CHECK', '1'),\n        ('PYTHONHOME', UNSET),\n        ('VIRTUAL_ENV', venv),\n        ('PATH', (bin_dir(venv), os.pathsep, Var('PATH'))),\n    )\n\n\ndef _find_by_py_launcher(\n        version: str,\n) -> Optional[str]:  # pragma: no cover (windows only)\n    if version.startswith('python'):\n        num = version[len('python'):]\n        cmd = ('py', f'-{num}', '-c', 'import sys; print(sys.executable)')\n        env = dict(os.environ, PYTHONIOENCODING='UTF-8')\n        try:\n            return cmd_output(*cmd, env=env)[1].strip()\n        except CalledProcessError:\n            pass\n    return None\n\n\ndef _find_by_sys_executable() -> Optional[str]:\n    def _norm(path: str) -> Optional[str]:\n        _, exe = os.path.split(path.lower())\n        exe, _, _ = exe.partition('.exe')\n        if exe not in {'python', 'pythonw'} and find_executable(exe):\n            return exe\n        return None\n\n    # On linux, I see these common sys.executables:\n    #\n    # system `python`: /usr/bin/python -> python2.7\n    # system `python2`: /usr/bin/python2 -> python2.7\n    # virtualenv v: v/bin/python (will not return from this loop)\n    # virtualenv v -ppython2: v/bin/python -> python2\n    # virtualenv v -ppython2.7: v/bin/python -> python2.7\n    # virtualenv v -ppypy: v/bin/python -> v/bin/pypy\n    for path in (sys.executable, os.path.realpath(sys.executable)):\n        exe = _norm(path)\n        if exe:\n            return exe\n    return None\n\n\n@functools.lru_cache(maxsize=1)\ndef get_default_version() -> str:  # pragma: no cover (platform dependent)\n    # First attempt from `sys.executable` (or the realpath)\n    exe = _find_by_sys_executable()\n    if exe:\n        return exe\n\n    # Next try the `pythonX.X` executable\n    exe = f'python{sys.version_info[0]}.{sys.version_info[1]}'\n    if find_executable(exe):\n        return exe\n\n    if _find_by_py_launcher(exe):\n        return exe\n\n    # We tried!\n    return C.DEFAULT\n\n\ndef _sys_executable_matches(version: str) -> bool:\n    if version == 'python':\n        return True\n    elif not version.startswith('python'):\n        return False\n\n    try:\n        info = tuple(int(p) for p in version[len('python'):].split('.'))\n    except ValueError:\n        return False\n\n    return sys.version_info[:len(info)] == info\n\n\ndef norm_version(version: str) -> Optional[str]:\n    if version == C.DEFAULT:  # use virtualenv's default\n        return None\n    elif _sys_executable_matches(version):  # virtualenv defaults to our exe\n        return None\n\n    if os.name == 'nt':  # pragma: no cover (windows)\n        version_exec = _find_by_py_launcher(version)\n        if version_exec:\n            return version_exec\n\n        # Try looking up by name\n        version_exec = find_executable(version)\n        if version_exec and version_exec != version:\n            return version_exec\n\n    # Otherwise assume it is a path\n    return os.path.expanduser(version)\n\n\n@contextlib.contextmanager\ndef in_env(\n        prefix: Prefix,\n        language_version: str,\n) -> Generator[None, None, None]:\n    directory = helpers.environment_dir(ENVIRONMENT_DIR, language_version)\n    envdir = prefix.path(directory)\n    with envcontext(get_env_patch(envdir)):\n        yield\n\n\ndef healthy(prefix: Prefix, language_version: str) -> bool:\n    directory = helpers.environment_dir(ENVIRONMENT_DIR, language_version)\n    envdir = prefix.path(directory)\n    pyvenv_cfg = os.path.join(envdir, 'pyvenv.cfg')\n\n    # created with \"old\" virtualenv\n    if not os.path.exists(pyvenv_cfg):\n        return False\n\n    exe_name = 'python.exe' if sys.platform == 'win32' else 'python'\n    py_exe = prefix.path(bin_dir(envdir), exe_name)\n    cfg = _read_pyvenv_cfg(pyvenv_cfg)\n\n    return (\n        'version_info' in cfg and\n        # always use uncached lookup here in case we replaced an unhealthy env\n        _version_info.__wrapped__(py_exe) == cfg['version_info'] and (\n            'base-executable' not in cfg or\n            _version_info(cfg['base-executable']) == cfg['version_info']\n        )\n    )\n\n\ndef install_environment(\n        prefix: Prefix,\n        version: str,\n        additional_dependencies: Sequence[str],\n) -> None:\n    envdir = prefix.path(helpers.environment_dir(ENVIRONMENT_DIR, version))\n    venv_cmd = [sys.executable, '-mvirtualenv', envdir]\n    python = norm_version(version)\n    if python is not None:\n        venv_cmd.extend(('-p', python))\n    install_cmd = ('python', '-mpip', 'install', '.', *additional_dependencies)\n\n    with clean_path_on_failure(envdir):\n        cmd_output_b(*venv_cmd, cwd='/')\n        with in_env(prefix, version):\n            helpers.run_setup_cmd(prefix, install_cmd)\n\n\ndef run_hook(\n        hook: Hook,\n        file_args: Sequence[str],\n        color: bool,\n) -> Tuple[int, bytes]:\n    with in_env(hook.prefix, hook.language_version):\n        return helpers.run_xargs(hook, hook.cmd, file_args, color=color)\n", "path": "pre_commit/languages/python.py"}], "after_files": [{"content": "import contextlib\nimport functools\nimport os\nimport sys\nfrom typing import Dict\nfrom typing import Generator\nfrom typing import Optional\nfrom typing import Sequence\nfrom typing import Tuple\n\nimport pre_commit.constants as C\nfrom pre_commit.envcontext import envcontext\nfrom pre_commit.envcontext import PatchesT\nfrom pre_commit.envcontext import UNSET\nfrom pre_commit.envcontext import Var\nfrom pre_commit.hook import Hook\nfrom pre_commit.languages import helpers\nfrom pre_commit.parse_shebang import find_executable\nfrom pre_commit.prefix import Prefix\nfrom pre_commit.util import CalledProcessError\nfrom pre_commit.util import clean_path_on_failure\nfrom pre_commit.util import cmd_output\nfrom pre_commit.util import cmd_output_b\n\nENVIRONMENT_DIR = 'py_env'\n\n\n@functools.lru_cache(maxsize=None)\ndef _version_info(exe: str) -> str:\n    prog = 'import sys;print(\".\".join(str(p) for p in sys.version_info))'\n    try:\n        return cmd_output(exe, '-S', '-c', prog)[1].strip()\n    except CalledProcessError:\n        return f'<<error retrieving version from {exe}>>'\n\n\ndef _read_pyvenv_cfg(filename: str) -> Dict[str, str]:\n    ret = {}\n    with open(filename, encoding='UTF-8') as f:\n        for line in f:\n            try:\n                k, v = line.split('=')\n            except ValueError:  # blank line / comment / etc.\n                continue\n            else:\n                ret[k.strip()] = v.strip()\n    return ret\n\n\ndef bin_dir(venv: str) -> str:\n    \"\"\"On windows there's a different directory for the virtualenv\"\"\"\n    bin_part = 'Scripts' if os.name == 'nt' else 'bin'\n    return os.path.join(venv, bin_part)\n\n\ndef get_env_patch(venv: str) -> PatchesT:\n    return (\n        ('PIP_DISABLE_PIP_VERSION_CHECK', '1'),\n        ('PYTHONHOME', UNSET),\n        ('VIRTUAL_ENV', venv),\n        ('PATH', (bin_dir(venv), os.pathsep, Var('PATH'))),\n    )\n\n\ndef _find_by_py_launcher(\n        version: str,\n) -> Optional[str]:  # pragma: no cover (windows only)\n    if version.startswith('python'):\n        num = version[len('python'):]\n        cmd = ('py', f'-{num}', '-c', 'import sys; print(sys.executable)')\n        env = dict(os.environ, PYTHONIOENCODING='UTF-8')\n        try:\n            return cmd_output(*cmd, env=env)[1].strip()\n        except CalledProcessError:\n            pass\n    return None\n\n\ndef _find_by_sys_executable() -> Optional[str]:\n    def _norm(path: str) -> Optional[str]:\n        _, exe = os.path.split(path.lower())\n        exe, _, _ = exe.partition('.exe')\n        if exe not in {'python', 'pythonw'} and find_executable(exe):\n            return exe\n        return None\n\n    # On linux, I see these common sys.executables:\n    #\n    # system `python`: /usr/bin/python -> python2.7\n    # system `python2`: /usr/bin/python2 -> python2.7\n    # virtualenv v: v/bin/python (will not return from this loop)\n    # virtualenv v -ppython2: v/bin/python -> python2\n    # virtualenv v -ppython2.7: v/bin/python -> python2.7\n    # virtualenv v -ppypy: v/bin/python -> v/bin/pypy\n    for path in (sys.executable, os.path.realpath(sys.executable)):\n        exe = _norm(path)\n        if exe:\n            return exe\n    return None\n\n\n@functools.lru_cache(maxsize=1)\ndef get_default_version() -> str:  # pragma: no cover (platform dependent)\n    # First attempt from `sys.executable` (or the realpath)\n    exe = _find_by_sys_executable()\n    if exe:\n        return exe\n\n    # Next try the `pythonX.X` executable\n    exe = f'python{sys.version_info[0]}.{sys.version_info[1]}'\n    if find_executable(exe):\n        return exe\n\n    if _find_by_py_launcher(exe):\n        return exe\n\n    # We tried!\n    return C.DEFAULT\n\n\ndef _sys_executable_matches(version: str) -> bool:\n    if version == 'python':\n        return True\n    elif not version.startswith('python'):\n        return False\n\n    try:\n        info = tuple(int(p) for p in version[len('python'):].split('.'))\n    except ValueError:\n        return False\n\n    return sys.version_info[:len(info)] == info\n\n\ndef norm_version(version: str) -> Optional[str]:\n    if version == C.DEFAULT:  # use virtualenv's default\n        return None\n    elif _sys_executable_matches(version):  # virtualenv defaults to our exe\n        return None\n\n    if os.name == 'nt':  # pragma: no cover (windows)\n        version_exec = _find_by_py_launcher(version)\n        if version_exec:\n            return version_exec\n\n        # Try looking up by name\n        version_exec = find_executable(version)\n        if version_exec and version_exec != version:\n            return version_exec\n\n    # Otherwise assume it is a path\n    return os.path.expanduser(version)\n\n\n@contextlib.contextmanager\ndef in_env(\n        prefix: Prefix,\n        language_version: str,\n) -> Generator[None, None, None]:\n    directory = helpers.environment_dir(ENVIRONMENT_DIR, language_version)\n    envdir = prefix.path(directory)\n    with envcontext(get_env_patch(envdir)):\n        yield\n\n\ndef healthy(prefix: Prefix, language_version: str) -> bool:\n    directory = helpers.environment_dir(ENVIRONMENT_DIR, language_version)\n    envdir = prefix.path(directory)\n    pyvenv_cfg = os.path.join(envdir, 'pyvenv.cfg')\n\n    # created with \"old\" virtualenv\n    if not os.path.exists(pyvenv_cfg):\n        return False\n\n    exe_name = 'python.exe' if sys.platform == 'win32' else 'python'\n    py_exe = prefix.path(bin_dir(envdir), exe_name)\n    cfg = _read_pyvenv_cfg(pyvenv_cfg)\n\n    return (\n        'version_info' in cfg and\n        # always use uncached lookup here in case we replaced an unhealthy env\n        _version_info.__wrapped__(py_exe) == cfg['version_info'] and (\n            'base-executable' not in cfg or\n            _version_info(cfg['base-executable']) == cfg['version_info']\n        )\n    )\n\n\ndef install_environment(\n        prefix: Prefix,\n        version: str,\n        additional_dependencies: Sequence[str],\n) -> None:\n    envdir = prefix.path(helpers.environment_dir(ENVIRONMENT_DIR, version))\n    venv_cmd = [sys.executable, '-mvirtualenv', envdir]\n    python = norm_version(version)\n    if python is not None:\n        venv_cmd.extend(('-p', python))\n    install_cmd = ('python', '-mpip', 'install', '.', *additional_dependencies)\n\n    with clean_path_on_failure(envdir):\n        cmd_output_b(*venv_cmd, cwd='/')\n        with in_env(prefix, version):\n            helpers.run_setup_cmd(prefix, install_cmd)\n\n\ndef run_hook(\n        hook: Hook,\n        file_args: Sequence[str],\n        color: bool,\n) -> Tuple[int, bytes]:\n    with in_env(hook.prefix, hook.language_version):\n        return helpers.run_xargs(hook, hook.cmd, file_args, color=color)\n", "path": "pre_commit/languages/python.py"}]}