python-discovery 1.9.1__py3-none-any.whl → 1.9.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -4,13 +4,17 @@ from __future__ import annotations
4
4
 
5
5
  import json
6
6
  import logging
7
+ import os
8
+ import stat
7
9
  from contextlib import contextmanager, suppress
8
10
  from hashlib import sha256
11
+ from os import fsencode
12
+ from pathlib import Path
13
+ from tempfile import NamedTemporaryFile
9
14
  from typing import TYPE_CHECKING, Final, Protocol, runtime_checkable
10
15
 
11
16
  if TYPE_CHECKING:
12
17
  from collections.abc import Generator
13
- from pathlib import Path
14
18
 
15
19
  _LOGGER: Final[logging.Logger] = logging.getLogger(__name__)
16
20
 
@@ -79,23 +83,58 @@ class DiskContentStore:
79
83
  def read(self) -> dict | None:
80
84
  data, bad_format = None, False
81
85
  try:
82
- data = json.loads(self._file.read_text(encoding="utf-8"))
83
- except ValueError:
86
+ data, bad_format = self._read_entry()
87
+ except (ValueError, RecursionError):
84
88
  bad_format = True
85
89
  except OSError:
86
90
  _LOGGER.debug("failed to read %s", self._file, exc_info=True)
91
+ bad_format = self._file.is_symlink()
87
92
  else:
88
- _LOGGER.debug("got python info from %s", self._file)
89
- return data
93
+ if not bad_format:
94
+ _LOGGER.debug("got python info from %s", self._file)
95
+ return data
90
96
  if bad_format:
91
97
  with suppress(OSError):
92
98
  self.remove()
93
99
  return None
94
100
 
101
+ def _read_entry(self) -> tuple[dict | None, bool]:
102
+ with open(self._file, encoding="utf-8", opener=self._open_entry) as file:
103
+ status = os.fstat(file.fileno())
104
+ if not stat.S_ISREG(status.st_mode) or (
105
+ hasattr(os, "geteuid") and (status.st_uid not in {os.geteuid(), 0} or status.st_mode & 0o022)
106
+ ):
107
+ _LOGGER.warning("ignoring untrusted cache entry at %s", self._file)
108
+ return None, True
109
+ # A 1 MiB query can expand to 12 MiB when supplementary Unicode is escaped.
110
+ if status.st_size > 16 << 20:
111
+ _LOGGER.warning("ignoring oversized cache entry at %s", self._file)
112
+ return None, True
113
+ return json.load(file), False
114
+
115
+ @staticmethod
116
+ def _open_entry(path: str, flags: int) -> int:
117
+ return os.open(path, flags | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0))
118
+
95
119
  def write(self, content: dict) -> None:
96
120
  self._folder.mkdir(parents=True, exist_ok=True)
97
- self._file.write_text(json.dumps(content, sort_keys=True, indent=2), encoding="utf-8")
98
- _LOGGER.debug("wrote python info at %s", self._file)
121
+ temporary: Path | None = None
122
+ try:
123
+ with NamedTemporaryFile(
124
+ mode="w", encoding="utf-8", dir=self._folder, prefix=f".{self._key}.", delete=False
125
+ ) as file:
126
+ temporary = Path(file.name)
127
+ # Compact encoding avoids indentation growth and the streaming encoder's recursion limit.
128
+ file.write(json.dumps(content, sort_keys=True))
129
+ temporary.replace(self._file)
130
+ except OSError:
131
+ _LOGGER.debug("failed to write %s", self._file, exc_info=True)
132
+ else:
133
+ _LOGGER.debug("wrote python info at %s", self._file)
134
+ finally:
135
+ if temporary is not None:
136
+ with suppress(OSError):
137
+ temporary.unlink(missing_ok=True)
99
138
 
100
139
  def remove(self) -> None:
101
140
  with suppress(OSError):
@@ -106,9 +145,15 @@ class DiskContentStore:
106
145
  def locked(self) -> Generator[None]:
107
146
  from filelock import FileLock # ruff:ignore[import-outside-top-level]
108
147
 
109
- lock_path = self._folder / f"{self._key}.lock"
110
- lock_path.parent.mkdir(parents=True, exist_ok=True)
111
- with FileLock(str(lock_path)):
148
+ self._folder.mkdir(parents=True, exist_ok=True)
149
+ if os.name == "posix":
150
+ group_shared = bool(self._folder.stat().st_mode & stat.S_IWGRP)
151
+ lock_folder = self._folder / "locks-v2"
152
+ lock_folder.mkdir(mode=0o770 if group_shared else 0o700, exist_ok=True)
153
+ lock = FileLock(str(lock_folder / f"{self._key}.lock"), mode=0o660 if group_shared else 0o600)
154
+ else:
155
+ lock = FileLock(str(self._folder / f"{self._key}.lock"))
156
+ with lock:
112
157
  yield
113
158
 
114
159
 
@@ -120,25 +165,52 @@ class DiskCache:
120
165
  """
121
166
 
122
167
  def __init__(self, root: Path) -> None:
123
- self._root = root
168
+ self._root = Path(os.path.abspath(root)) # ruff:ignore[os-path-abspath] # resolve() follows untrusted links
124
169
 
125
170
  @property
126
171
  def _py_info_dir(self) -> Path:
127
172
  return self._root / "py_info" / "4"
128
173
 
129
- def py_info(self, path: Path) -> DiskContentStore:
174
+ def py_info(self, path: Path) -> ContentStore:
130
175
  """
131
176
  Return the content store for the interpreter at *path*.
132
177
 
133
178
  :param path: absolute path to a Python executable.
134
179
  """
135
- key = sha256(str(path).encode("utf-8")).hexdigest()
180
+ if not self._trusted_folder():
181
+ return NoOpContentStore()
182
+ key = sha256(fsencode(path)).hexdigest()
136
183
  return DiskContentStore(self._py_info_dir, key)
137
184
 
185
+ def _trusted_folder(self) -> bool:
186
+ if not hasattr(os, "geteuid"):
187
+ return True
188
+ user_id = os.geteuid()
189
+ folder = self._py_info_dir
190
+ private = {self._root, folder.parent, folder}
191
+ for candidate in (*reversed(folder.parents), folder):
192
+ try:
193
+ try:
194
+ status = candidate.lstat()
195
+ except FileNotFoundError:
196
+ candidate.mkdir(exist_ok=True)
197
+ status = candidate.lstat()
198
+ except OSError:
199
+ _LOGGER.warning("not caching in %s", candidate, exc_info=True)
200
+ return False
201
+ if (
202
+ not stat.S_ISDIR(status.st_mode)
203
+ or status.st_uid not in {user_id, 0}
204
+ or (status.st_mode & 0o022 and (candidate in private or not status.st_mode & stat.S_ISVTX))
205
+ ):
206
+ _LOGGER.warning("not caching in untrusted directory %s", candidate)
207
+ return False
208
+ return True
209
+
138
210
  def py_info_clear(self) -> None:
139
211
  """Remove all cached interpreter information."""
140
212
  folder = self._py_info_dir
141
- if folder.exists():
213
+ if folder.exists() and self._trusted_folder():
142
214
  for entry in folder.iterdir():
143
215
  if entry.suffix == ".json":
144
216
  with suppress(OSError):
@@ -3,29 +3,36 @@
3
3
  from __future__ import annotations
4
4
 
5
5
  import hashlib
6
- import json
7
6
  import logging
8
7
  import os
9
8
  import pkgutil
10
9
  import secrets
11
- import subprocess # ruff:ignore[suspicious-subprocess-import]
12
10
  import sys
13
11
  import tempfile
12
+ from codecs import getincrementaldecoder
14
13
  from collections import OrderedDict
15
- from contextlib import contextmanager
14
+ from contextlib import contextmanager, suppress
15
+ from dataclasses import dataclass
16
16
  from functools import lru_cache
17
+ from io import DEFAULT_BUFFER_SIZE, IncrementalNewlineDecoder
17
18
  from pathlib import Path
19
+ from select import select
18
20
  from shlex import quote
19
- from subprocess import Popen, TimeoutExpired # ruff:ignore[suspicious-subprocess-import]
21
+ from subprocess import DEVNULL, PIPE, Popen, TimeoutExpired, list2cmdline # ruff:ignore[suspicious-subprocess-import]
22
+ from threading import Event, Thread
23
+ from time import monotonic
20
24
  from typing import TYPE_CHECKING, Final
21
25
 
22
26
  from ._cache import NoOpCache
23
27
  from ._py_info import PythonInfo
24
28
  from ._py_info_collect import MIN_INTERROGATE_VERSION, UNSUPPORTED_EXIT_CODE, UNSUPPORTED_MARKER
25
29
 
30
+ if sys.platform == "win32": # pragma: win32 cover
31
+ from ._windows._cancel_io import stop_query_reader
32
+
26
33
  if TYPE_CHECKING:
27
34
  from collections.abc import Generator, Mapping
28
- from typing import TypedDict
35
+ from typing import IO, TypedDict
29
36
 
30
37
  from ._cache import ContentStore, PyInfoCache
31
38
 
@@ -45,11 +52,16 @@ _PY_INFO_SCRIPT: Final[Path] = Path(__file__).resolve().parent / "_py_info_colle
45
52
  _DEFAULT_QUERY_TIMEOUT: Final[float] = 15.0
46
53
  # poll(2) limits milliseconds to a signed C int.
47
54
  _MAX_QUERY_TIMEOUT: Final[float] = (2**31 - 1) / 1000
55
+ _MAX_QUERY_OUTPUT: Final[int] = 1 << 20
48
56
 
49
57
 
50
58
  class _UnsupportedInterpreterError(RuntimeError):
51
59
  """The interpreter is older than the interrogation script supports; retrying cannot help."""
52
60
 
61
+ def __init__(self, message: str, executable: str | None = None) -> None:
62
+ super().__init__(message)
63
+ self.executable = executable
64
+
53
65
 
54
66
  def from_exe( # ruff:ignore[too-many-arguments]
55
67
  cls: type[PythonInfo],
@@ -62,7 +74,14 @@ def from_exe( # ruff:ignore[too-many-arguments]
62
74
  executable_args: str | None = None,
63
75
  ) -> PythonInfo | None:
64
76
  env = os.environ if env is None else env
65
- result = _get_from_cache(cls, cache, exe, env, ignore_cache=ignore_cache, executable_args=executable_args)
77
+ if cache is None:
78
+ result = _get_from_cache(cls, cache, exe, env, ignore_cache=ignore_cache, executable_args=executable_args)
79
+ else:
80
+ try:
81
+ result = _get_from_cache(cls, cache, exe, env, ignore_cache=ignore_cache, executable_args=executable_args)
82
+ except OSError:
83
+ _LOGGER.debug("failed to use cache for %s", exe, exc_info=True)
84
+ result = _get_from_cache(cls, None, exe, env, ignore_cache=True, executable_args=executable_args)
66
85
  if isinstance(result, Exception):
67
86
  if raise_on_error:
68
87
  raise result
@@ -84,13 +103,32 @@ def _get_from_cache( # ruff:ignore[too-many-arguments]
84
103
  if not ignore_cache and key in _CACHE:
85
104
  result = _CACHE[key]
86
105
  else:
87
- result = _CACHE[key] = _get_via_file_cache(cls, cache, key[0], exe, env, executable_args=executable_args)
106
+ result = _get_via_file_cache(cls, cache, key[0], exe, env, executable_args=executable_args)
107
+ if _cacheable_result(key[0], result):
108
+ _CACHE[key] = result
109
+ else:
110
+ _CACHE.pop(key, None)
88
111
  # with launcher arguments the queried binary is not the interpreter, so keep the one the query reported
89
112
  if isinstance(result, PythonInfo) and executable_args is None:
90
113
  result.executable = exe
91
114
  return result
92
115
 
93
116
 
117
+ def _cacheable_result(path: Path, result: PythonInfo | Exception) -> bool:
118
+ if isinstance(result, PythonInfo):
119
+ executable = result.original_executable
120
+ elif isinstance(result, _UnsupportedInterpreterError):
121
+ executable = result.executable
122
+ else:
123
+ return False
124
+ if executable is None:
125
+ return False
126
+ try:
127
+ return path.samefile(executable)
128
+ except (OSError, TypeError, ValueError):
129
+ return False
130
+
131
+
94
132
  def _get_via_file_cache( # ruff:ignore[too-many-arguments]
95
133
  cls: type[PythonInfo],
96
134
  cache: PyInfoCache | None,
@@ -120,26 +158,25 @@ def _get_via_file_cache( # ruff:ignore[too-many-arguments]
120
158
  }
121
159
  with py_info_store.locked():
122
160
  cached = _read_cache_entry(cls, py_info_store, entry_meta)
123
- if isinstance(cached, _UnsupportedInterpreterError):
161
+ if cached is not None:
124
162
  return cached
125
- py_info = cached
126
- if py_info is None:
163
+ failure, py_info = _run_subprocess(cls, exe, env, executable_args)
164
+ if failure is not None and not isinstance(failure, _UnsupportedInterpreterError):
165
+ _LOGGER.debug("first subprocess attempt failed for %s (%s), retrying", exe, failure)
127
166
  failure, py_info = _run_subprocess(cls, exe, env, executable_args)
128
- if failure is not None and not isinstance(failure, _UnsupportedInterpreterError):
129
- _LOGGER.debug("first subprocess attempt failed for %s (%s), retrying", exe, failure)
130
- failure, py_info = _run_subprocess(cls, exe, env, executable_args)
131
- if isinstance(failure, _UnsupportedInterpreterError):
132
- _LOGGER.warning("%s", failure) # the verdict is permanent, warn once and remember it
167
+ if isinstance(failure, _UnsupportedInterpreterError):
168
+ _LOGGER.warning("%s", failure)
169
+ if _cacheable_result(path, failure):
133
170
  py_info_store.write({**entry_meta, "unsupported": str(failure)})
134
- return failure
135
- if failure is not None:
136
- return failure
137
- if py_info is not None:
138
- py_info_store.write({**entry_meta, "content": py_info.to_dict()})
139
- if py_info is None:
140
- msg = f"{exe} failed to produce interpreter info"
141
- return RuntimeError(msg)
142
- return py_info
171
+ return failure
172
+ if failure is not None:
173
+ return failure
174
+ if py_info is None:
175
+ msg = f"{exe} failed to produce interpreter info"
176
+ return RuntimeError(msg)
177
+ if _cacheable_result(path, py_info):
178
+ py_info_store.write({**entry_meta, "content": py_info.to_dict()})
179
+ return py_info
143
180
 
144
181
 
145
182
  def _read_cache_entry(
@@ -151,7 +188,7 @@ def _read_cache_entry(
151
188
  return None
152
189
  if isinstance(data, dict) and all(data.get(key) == value for key, value in entry_meta.items()):
153
190
  if isinstance(unsupported := data.get("unsupported"), str):
154
- return _UnsupportedInterpreterError(unsupported)
191
+ return _UnsupportedInterpreterError(unsupported, entry_meta["path"])
155
192
  if isinstance(content := data.get("content"), dict):
156
193
  return _load_cached_py_info(cls, py_info_store, content)
157
194
  py_info_store.remove()
@@ -166,7 +203,7 @@ def _load_cached_py_info(
166
203
  try:
167
204
  py_info = cls.from_dict(content.copy())
168
205
  stale = (sys_exe := py_info.system_executable) is not None and not Path(sys_exe).is_file()
169
- except (AttributeError, KeyError, OSError, TypeError):
206
+ except (AttributeError, KeyError, OSError, TypeError, ValueError):
170
207
  stale = True
171
208
  if stale:
172
209
  py_info_store.remove()
@@ -195,13 +232,11 @@ def _resolve_py_info_script() -> Generator[Path]:
195
232
  if data is None:
196
233
  msg = f"cannot locate {_PY_INFO_SCRIPT.name} for subprocess interrogation"
197
234
  raise FileNotFoundError(msg)
198
- fd, tmp = tempfile.mkstemp(suffix=".py")
199
- try:
200
- os.write(fd, data)
201
- os.close(fd)
202
- yield Path(tmp)
203
- finally:
204
- Path(tmp).unlink()
235
+ # Python prepends the probe script's directory to sys.path, so keep that directory private.
236
+ with tempfile.TemporaryDirectory() as private_dir:
237
+ script: Final[Path] = Path(private_dir) / _PY_INFO_SCRIPT.name
238
+ script.write_bytes(data)
239
+ yield script
205
240
 
206
241
 
207
242
  def _extract_between_cookies(out: str, start_cookie: str, end_cookie: str) -> tuple[str, str, int, int]:
@@ -233,7 +268,7 @@ def _run_subprocess(
233
268
  cmd: list[str] | str = [exe, str(py_info_script), start_cookie, end_cookie]
234
269
  if executable_args is not None:
235
270
  # PEP 514 ExecutableArguments is raw command line text, placed before the script per the PEP
236
- cmd = f"{subprocess.list2cmdline(cmd[:1])} {executable_args} {subprocess.list2cmdline(cmd[1:])}"
271
+ cmd = f"{list2cmdline(cmd[:1])} {executable_args} {list2cmdline(cmd[1:])}"
237
272
  env = dict(env)
238
273
  env.pop("__PYVENV_LAUNCHER__", None)
239
274
  env["PYTHONUTF8"] = "1"
@@ -242,31 +277,31 @@ def _run_subprocess(
242
277
  process = Popen( # ruff:ignore[subprocess-without-shell-equals-true]
243
278
  cmd,
244
279
  universal_newlines=True,
245
- stdin=subprocess.PIPE,
246
- stderr=subprocess.PIPE,
247
- stdout=subprocess.PIPE,
280
+ stdin=DEVNULL,
281
+ stderr=PIPE,
282
+ stdout=PIPE,
248
283
  env=env,
249
284
  encoding="utf-8",
250
285
  errors="backslashreplace",
251
286
  )
252
- out, err = process.communicate(timeout=timeout)
253
- code = process.returncode
254
- except TimeoutExpired:
255
- process.kill()
256
- process.communicate()
257
- out, err, code = "", "timed out", -1
287
+ out, err, code = _collect_query_output(process, timeout)
258
288
  except OSError as os_error:
259
289
  out, err, code = "", os_error.strerror, os_error.errno
260
290
  if code != 0:
261
291
  return _query_failure(exe, out, err, code), None
262
292
  out, raw_out, out_starts, out_ends = _extract_between_cookies(out, start_cookie, end_cookie)
293
+ if out_starts < 0 or out_ends < 0:
294
+ _LOGGER.warning("subprocess %s omitted query markers; stdout %d chars", exe, len(raw_out))
295
+ msg = f"{exe} returned output without query markers"
296
+ return RuntimeError(msg), None
263
297
  try:
264
298
  result = cls.from_json(out)
265
299
  if executable_args is None:
266
300
  result.executable = exe
267
- except json.JSONDecodeError as exc:
301
+ except (AttributeError, KeyError, TypeError, ValueError) as exc:
268
302
  _LOGGER.warning(
269
- "subprocess %s returned invalid JSON; raw stdout %d chars, start cookie %s, end cookie %s, "
303
+ "subprocess %s returned invalid interpreter information; "
304
+ "raw stdout %d chars, start cookie %s, end cookie %s, "
270
305
  "parsed output %d chars: %r",
271
306
  exe,
272
307
  len(raw_out),
@@ -275,13 +310,102 @@ def _run_subprocess(
275
310
  len(out),
276
311
  out[:200] if out else "<empty>",
277
312
  )
278
- msg = f"{exe} returned invalid JSON (exit code {code}){f', stderr: {err!r}' if err else ''}"
313
+ msg = f"{exe} returned invalid interpreter information (exit code {code}){f', stderr: {err!r}' if err else ''}"
279
314
  failure = RuntimeError(msg)
280
315
  failure.__cause__ = exc
281
316
  return failure, None
282
317
  return None, result
283
318
 
284
319
 
320
+ def _collect_query_output(process: Popen[str], timeout: float | None) -> tuple[str, str, int]:
321
+ stdout, stderr = process.stdout, process.stderr
322
+ if stdout is None or stderr is None:
323
+ msg = "query output pipes are required"
324
+ raise ValueError(msg)
325
+ out_chunks: list[str] = []
326
+ err_chunks: list[str] = []
327
+ state = _QueryReadState(process=process, overflow=Event(), stop=Event(), read_errors=[])
328
+
329
+ readers = (
330
+ Thread(target=_drain_query_stream, args=(state, stdout, out_chunks), daemon=True),
331
+ Thread(target=_drain_query_stream, args=(state, stderr, err_chunks), daemon=True),
332
+ )
333
+ for reader in readers:
334
+ reader.start()
335
+ if not _query_completed(process, readers, timeout):
336
+ state.stop.set()
337
+ with suppress(OSError):
338
+ process.kill()
339
+ # A descendant may keep the pipes open after the candidate exits.
340
+ process.wait()
341
+ _stop_query_readers(readers)
342
+ return "", "timed out", -1
343
+ if state.read_errors:
344
+ raise state.read_errors[0]
345
+ if state.overflow.is_set():
346
+ return "", f"produced more than {_MAX_QUERY_OUTPUT} characters of output", -1
347
+ return "".join(out_chunks), "".join(err_chunks), process.wait()
348
+
349
+
350
+ @dataclass(frozen=True)
351
+ class _QueryReadState:
352
+ process: Popen[str]
353
+ overflow: Event
354
+ stop: Event
355
+ read_errors: list[OSError]
356
+
357
+
358
+ def _stop_query_readers(readers: tuple[Thread, Thread]) -> None:
359
+ for reader in readers:
360
+ if sys.platform == "win32": # pragma: win32 cover
361
+ stop_query_reader(reader)
362
+ else:
363
+ reader.join()
364
+
365
+
366
+ def _query_completed(process: Popen[str], readers: tuple[Thread, Thread], timeout: float | None) -> bool:
367
+ deadline = None if timeout is None else monotonic() + timeout
368
+ for reader in readers:
369
+ reader.join(None if deadline is None else max(deadline - monotonic(), 0))
370
+ if any(reader.is_alive() for reader in readers):
371
+ return False
372
+ try:
373
+ process.wait(timeout=None if deadline is None else max(deadline - monotonic(), 0))
374
+ except TimeoutExpired:
375
+ return False
376
+ return True
377
+
378
+
379
+ def _drain_query_stream(state: _QueryReadState, stream: IO[str], chunks: list[str]) -> None:
380
+ size = 0
381
+ failed = False
382
+ decoder = IncrementalNewlineDecoder(getincrementaldecoder("utf-8")("backslashreplace"), translate=True)
383
+ with stream:
384
+ while not state.stop.is_set():
385
+ try:
386
+ if sys.platform != "win32" and not select([stream], [], [], 0.05)[0]: # pragma: win32 cover
387
+ continue
388
+ data = os.read(stream.fileno(), DEFAULT_BUFFER_SIZE)
389
+ except OSError as error:
390
+ if not state.stop.is_set(): # pragma: win32 cover # canceled ReadFile raises on Windows
391
+ state.read_errors.append(error)
392
+ failed = True
393
+ break
394
+ chunk = decoder.decode(data, final=not data)
395
+ if chunk:
396
+ chunks.append(chunk[: _MAX_QUERY_OUTPUT + 1 - size])
397
+ size += len(chunk)
398
+ if size > _MAX_QUERY_OUTPUT:
399
+ state.overflow.set()
400
+ failed = True
401
+ break
402
+ if not data:
403
+ break
404
+ if failed:
405
+ with suppress(OSError):
406
+ state.process.kill()
407
+
408
+
285
409
  @lru_cache(maxsize=128)
286
410
  def _query_timeout(raw: str | None) -> float | None:
287
411
  if raw is None:
@@ -302,10 +426,12 @@ def _query_failure(exe: str, out: str, err: str | None, code: int | None) -> Run
302
426
  # the gate's exit code and stderr marker must both be present: either alone can collide, an errno of 79 from a
303
427
  # failed exec or a shim that echoes the marker phrase, but only the gate produces the combination
304
428
  if code == UNSUPPORTED_EXIT_CODE and err is not None and (at := err.find(UNSUPPORTED_MARKER)) != -1:
305
- version = err[at + len(UNSUPPORTED_MARKER) :].split() or ["unknown"]
429
+ details = err[at + len(UNSUPPORTED_MARKER) :].splitlines()
430
+ version = details[0].split() if details else []
306
431
  floor = ".".join(str(i) for i in MIN_INTERROGATE_VERSION)
307
- msg = f"{exe} is Python {version[0]}, older than the minimum {floor} python-discovery can query"
308
- return _UnsupportedInterpreterError(msg)
432
+ found = version[0] if version else "unknown"
433
+ msg = f"{exe} is Python {found}, older than the minimum {floor} python-discovery can query"
434
+ return _UnsupportedInterpreterError(msg, details[1].strip() if len(details) > 1 else None)
309
435
  msg = f"{exe} with code {code}{f' out: {out!r}' if out else ''}{f' err: {err!r}' if err else ''}"
310
436
  return RuntimeError(f"failed to query {msg}")
311
437
 
@@ -6,12 +6,13 @@ import sys
6
6
  from contextlib import suppress
7
7
  from dataclasses import dataclass
8
8
  from itertools import tee
9
+ from os.path import basename
9
10
  from pathlib import Path
10
11
  from typing import TYPE_CHECKING, Final
11
12
 
12
13
  from ._compat import fs_path_id
13
14
  from ._py_info import PythonInfo
14
- from ._py_spec import PythonSpec
15
+ from ._py_spec import KNOWN_IMPLEMENTATIONS, PythonSpec
15
16
  from ._specifier import DC_KW, SimpleVersion
16
17
 
17
18
  if TYPE_CHECKING:
@@ -42,7 +43,7 @@ def get_interpreter(
42
43
  (``>=3.10``). When a sequence is given each entry is tried in order.
43
44
  :param try_first_with: executables to probe before the normal discovery search.
44
45
  :param cache: interpreter metadata cache; when ``None`` results are not cached.
45
- :param env: environment mapping for ``PATH`` lookup; defaults to :data:`os.environ`.
46
+ :param env: environment mapping for ``PATH`` and uv store lookup; defaults to :data:`os.environ`.
46
47
  :param predicate: optional callback applied after an interpreter matches the spec. Return ``True`` to accept the
47
48
  interpreter, ``False`` to skip it and continue searching.
48
49
  :return: the first matching interpreter, or ``None`` if no match is found.
@@ -74,7 +75,7 @@ def iter_interpreters(
74
75
  :param try_first_with: executables to probe before the normal discovery search.
75
76
  :param cache: interpreter metadata cache; when ``None`` results are not cached. Strongly recommended for
76
77
  enumeration, which interrogates every candidate as a subprocess on a cold cache.
77
- :param env: environment mapping for ``PATH`` lookup; defaults to :data:`os.environ`.
78
+ :param env: environment mapping for ``PATH`` and uv store lookup; defaults to :data:`os.environ`.
78
79
  :param predicate: optional filter applied after the spec match; return ``True`` to include the interpreter.
79
80
  """
80
81
  if key is None:
@@ -186,7 +187,7 @@ def propose_interpreters(
186
187
  :param spec: the parsed interpreter specification to match against.
187
188
  :param try_first_with: executable paths to probe before the standard search.
188
189
  :param cache: interpreter metadata cache; when ``None`` results are not cached.
189
- :param env: environment mapping for ``PATH`` lookup; defaults to :data:`os.environ`.
190
+ :param env: environment mapping for ``PATH`` and uv store lookup; defaults to :data:`os.environ`.
190
191
  :param all_implementations: when ``True`` and *spec* does not constrain the implementation, also surface
191
192
  non-CPython binaries on ``PATH`` and under UV's install directory. Used by enumeration APIs.
192
193
  """
@@ -212,11 +213,12 @@ def _propose_explicit(
212
213
  tested_exes: set[str],
213
214
  ) -> Generator[tuple[PythonInfo | None, bool], None, None]:
214
215
  for py_exe in try_first_with:
215
- if exe_raw := _check_exe(str(Path(py_exe).resolve()), tested_exes):
216
+ if Path(py_exe).exists() and (exe_raw := _check_exe(py_exe, tested_exes)):
216
217
  yield PythonInfo.from_exe(exe_raw, cache, env=env), True
217
218
 
218
219
  if spec.path is not None:
219
- if exe_raw := _check_exe(spec.path, tested_exes): # pragma: no branch
220
+ # Unparsed bare names reach spec.path; only an explicit directory should search the working directory.
221
+ if os.path.dirname(spec.path) and (exe_raw := _check_exe(spec.path, tested_exes)):
220
222
  yield PythonInfo.from_exe(exe_raw, cache, env=env), True
221
223
  else:
222
224
  yield from _propose_current_and_windows(spec, cache, env, tested_exes)
@@ -288,24 +290,28 @@ def _uv_python_roots(env: Mapping[str, str]) -> Generator[Path, None, None]:
288
290
  yield Path(install_dir).expanduser()
289
291
  return
290
292
  for state_dir in _uv_state_dirs(env):
291
- yield state_dir / "python"
293
+ if state_dir.is_absolute(): # a relative profile path would search the caller's working directory
294
+ yield state_dir / "python"
292
295
 
293
296
 
294
297
  def _uv_state_dirs(env: Mapping[str, str]) -> Generator[Path, None, None]:
295
298
  """Yield uv's legacy state directory then its current one, the order uv prefers them in."""
296
- windows = sys.platform == "win32"
297
- home = Path(env.get("USERPROFILE" if windows else "HOME") or "~").expanduser()
299
+ windows: Final = sys.platform == "win32"
300
+ home: Final = Path(profile) if (profile := env.get("USERPROFILE" if windows else "HOME")) else None
298
301
  if windows:
299
- app_data = Path(env["APPDATA"]) if "APPDATA" in env else home / "AppData" / "Roaming"
300
- yield app_data / "uv" / "data"
301
- yield app_data / "uv"
302
+ app_data = Path(roaming) if (roaming := env.get("APPDATA")) else None
303
+ if app_data is None or not app_data.is_absolute():
304
+ app_data = home / "AppData" / "Roaming" if home is not None else None
305
+ if app_data is not None:
306
+ yield app_data / "uv" / "data"
307
+ yield app_data / "uv"
302
308
  return
303
- if sys.platform == "darwin":
309
+ if sys.platform == "darwin" and home is not None:
304
310
  yield home / "Library" / "Application Support" / "uv"
305
311
  # uv ignores a relative XDG_DATA_HOME, as the XDG specification requires
306
312
  if (xdg_data_home := env.get("XDG_DATA_HOME")) and (xdg := Path(xdg_data_home)).is_absolute():
307
313
  yield xdg / "uv"
308
- else:
314
+ elif home is not None:
309
315
  yield home / ".local" / "share" / "uv"
310
316
 
311
317
 
@@ -377,8 +383,24 @@ def _uv_version_matches(key: _UvKey, spec: PythonSpec) -> bool:
377
383
  # GraalPy keys carry the GraalVM version in older uv releases, so only CPython and PyPy state a Python version
378
384
  if key.implementation not in {"cpython", "pypy"}:
379
385
  return True
380
- if spec.version_specifier is not None and not spec.version_specifier.contains(str(key.version)):
381
- return False
386
+ if spec.version_specifier is not None:
387
+ for specifier in spec.version_specifier:
388
+ if specifier.version is None:
389
+ return False
390
+ # Match at the requested precision, as PythonInfo.satisfies does after probing.
391
+ numeric_version = specifier.version_str
392
+ for prefix in ("rc", "b", "a"):
393
+ if prefix in numeric_version:
394
+ numeric_version = numeric_version.split(prefix)[0]
395
+ break
396
+ precision = numeric_version.count(".") + 1
397
+ release = ".".join(str(part) for part in key.version.release[:precision])
398
+ if key.version.pre_type is not None and (
399
+ precision == 3 or specifier.version.pre_type is not None # ruff:ignore[magic-value-comparison]
400
+ ):
401
+ release = f"{release}{key.version.pre_type}{key.version.pre_num}"
402
+ if not specifier.contains(release):
403
+ return False
382
404
  return all(req is None or our == req for our, req in zip(key.version.release, (spec.major, spec.minor, spec.micro)))
383
405
 
384
406
 
@@ -426,14 +448,10 @@ def get_paths(env: Mapping[str, str]) -> Generator[Path, None, None]:
426
448
  except (AttributeError, ValueError): # pragma: no cover # Windows only (no confstr)
427
449
  path = os.defpath
428
450
  if path:
429
- # An empty component (a leading/trailing/doubled separator) means "the current directory", the
430
- # same footgun a shell has when PATH is misconfigured - Path("") resolves to it. Since every
431
- # yielded path here is later searched for interpreters to execute and interrogate, silently
432
- # including the caller's CWD would let whatever directory virtualenv happens to run from smuggle
433
- # in a candidate binary.
451
+ # Relative entries can execute an interpreter supplied by the working directory.
434
452
  for entry in map(Path, filter(None, path.split(os.pathsep))):
435
453
  with suppress(OSError):
436
- if entry.is_dir() and next(entry.iterdir(), None):
454
+ if entry.is_absolute() and entry.is_dir() and next(entry.iterdir(), None):
437
455
  yield entry
438
456
 
439
457
 
@@ -472,18 +490,19 @@ def path_exe_finder(
472
490
  """Given a spec, return a function that can be called on a path to find all matching files in it."""
473
491
  pat = spec.generate_re(windows=sys.platform == "win32", all_implementations=all_implementations)
474
492
  direct = spec.str_spec
493
+ implementation = spec.implementation.lower() if spec.implementation is not None else None
494
+ impl_must_match = implementation in KNOWN_IMPLEMENTATIONS and implementation != "python"
475
495
  if sys.platform == "win32": # pragma: win32 cover
476
496
  direct = f"{direct}.exe"
477
497
 
478
498
  def path_exes(path: Path) -> Generator[tuple[Path, bool], None, None]:
479
499
  direct_path = path / direct
480
500
  if direct_path.exists():
481
- yield direct_path, False
501
+ yield direct_path, impl_must_match
482
502
 
483
503
  for exe in path.iterdir():
484
- match = pat.fullmatch(exe.name)
485
- if match:
486
- yield exe.absolute(), match["impl"] == "python"
504
+ if pat.fullmatch(exe.name):
505
+ yield exe.absolute(), impl_must_match
487
506
 
488
507
  return path_exes
489
508
 
@@ -509,6 +528,9 @@ _VERSION_MANAGER_LAYOUTS: list[tuple[str, tuple[str, ...]]] = [
509
528
 
510
529
  def _resolve_shim_to_binary(exe_name: str, versions_dir: str, env: Mapping[str, str]) -> str | None:
511
530
  for version in _active_versions(env):
531
+ if version in {"", ".", ".."} or basename(version) != version:
532
+ _LOGGER.debug("ignoring invalid version name %r", version)
533
+ continue
512
534
  resolved = os.path.join(versions_dir, version, "bin", exe_name)
513
535
  if Path(resolved).is_file() and os.access(resolved, os.X_OK):
514
536
  return resolved
@@ -549,7 +571,13 @@ def _versions_in_file(path: str | Path) -> list[str]:
549
571
  try:
550
572
  # pyenv reads raw bytes, so a byte that is not UTF-8 (a Latin-1 comment, say) must not hide the versions
551
573
  with Path(path).open(encoding="utf-8", errors="replace") as fh:
552
- return [v for line in fh if (v := line.strip()) and not v.startswith("#")]
574
+ # Version files can sit in shared parent directories; bound the in-process read.
575
+ max_chars = 4096
576
+ content = fh.read(max_chars + 1)
577
+ if len(content) > max_chars:
578
+ _LOGGER.debug("ignored oversized version file %s", path)
579
+ return []
580
+ return [v for line in content.split("\n") if (v := line.strip()) and not v.startswith("#")]
553
581
  except OSError: # skip a file we cannot read, the same as one that names no version
554
582
  _LOGGER.debug("failed to read %s", path, exc_info=True)
555
583
  return []
@@ -10,7 +10,8 @@ import platform
10
10
  import sys
11
11
  from collections import OrderedDict
12
12
  from itertools import product
13
- from string import digits
13
+ from os.path import normcase, realpath
14
+ from string import Formatter, digits
14
15
  from typing import TYPE_CHECKING, ClassVar, Final, NamedTuple, TypedDict
15
16
 
16
17
  from ._py_info_collect import PythonInfoCollector
@@ -135,6 +136,9 @@ class PythonInfo: # ruff:ignore[too-many-public-methods]
135
136
  pattern = self.sysconfig_paths.get(key)
136
137
  if pattern is None:
137
138
  return ""
139
+ if any(format_spec for _, _, format_spec, _ in Formatter().parse(pattern)):
140
+ msg = f"sysconfig path {key!r} contains format specifiers"
141
+ raise ValueError(msg)
138
142
  if config_var is None:
139
143
  config_var = self.sysconfig_vars
140
144
  else:
@@ -283,7 +287,7 @@ class PythonInfo: # ruff:ignore[too-many-public-methods]
283
287
  return True
284
288
  if spec.is_abs:
285
289
  return True
286
- basename = os.path.basename(self.original_executable)
290
+ basename = os.path.basename(self.executable)
287
291
  spec_path = spec.path
288
292
  if sys.platform == "win32":
289
293
  basename, suffix = os.path.splitext(basename)
@@ -356,7 +360,7 @@ class PythonInfo: # ruff:ignore[too-many-public-methods]
356
360
 
357
361
  def to_dict(self) -> dict[str, InfoValue]:
358
362
  """Convert this interpreter information to a plain dictionary."""
359
- data = {var: (getattr(self, var) if var != "_creators" else None) for var in vars(self)}
363
+ data = {name: None if name == "_creators" else value for name, value in vars(self).items()}
360
364
  version_info = data["version_info"]
361
365
  data["version_info"] = version_info._asdict() if hasattr(version_info, "_asdict") else version_info
362
366
  return data
@@ -420,7 +424,7 @@ class PythonInfo: # ruff:ignore[too-many-public-methods]
420
424
 
421
425
  if isinstance(proposed, PythonInfo) and resolve_to_host:
422
426
  try:
423
- proposed = proposed.resolve_to_system(cache, proposed)
427
+ proposed = proposed.resolve_to_system(cache, proposed, env=env)
424
428
  except Exception as exception:
425
429
  if raise_on_error:
426
430
  raise
@@ -445,24 +449,31 @@ class PythonInfo: # ruff:ignore[too-many-public-methods]
445
449
 
446
450
  :param data: dictionary produced by :meth:`to_dict`.
447
451
  """
452
+ if missing := PythonInfo.__annotations__.keys() - data.keys() - {"_cache_exe_discovery", "pypy_version_info"}:
453
+ msg = f"missing interpreter information: {', '.join(sorted(missing))}"
454
+ raise ValueError(msg)
448
455
  data["version_info"] = VersionInfo(**data["version_info"]) # restore this to a named tuple structure
449
456
  result = cls.__new__(cls) # skip __init__, data replaces the full state
450
457
  result.__dict__ = data.copy()
451
458
  return result
452
459
 
453
460
  @classmethod
454
- def resolve_to_system(cls, cache: PyInfoCache | None, target: PythonInfo) -> PythonInfo:
461
+ def resolve_to_system(
462
+ cls, cache: PyInfoCache | None, target: PythonInfo, *, env: Mapping[str, str] | None = None
463
+ ) -> PythonInfo:
455
464
  """
456
465
  Walk virtualenv/venv prefix chains to find the underlying system interpreter.
457
466
 
458
467
  :param cache: interpreter metadata cache; when ``None`` results are not cached.
459
468
  :param target: the interpreter to resolve.
469
+ :param env: environment mapping; defaults to :data:`os.environ`.
460
470
  """
461
471
  start_executable = target.executable
462
472
  prefixes = OrderedDict()
463
473
  while target.system_executable is None:
464
474
  prefix = target.real_prefix or target.base_prefix or target.prefix
465
- if prefix in prefixes:
475
+ prefix_key = normcase(realpath(prefix))
476
+ if prefix_key in prefixes:
466
477
  if len(prefixes) == 1:
467
478
  _LOGGER.info("%r links back to itself via prefixes", target)
468
479
  target.system_executable = target.executable
@@ -472,10 +483,10 @@ class PythonInfo: # ruff:ignore[too-many-public-methods]
472
483
  _LOGGER.error("%d: prefix=%s, info=%r", len(prefixes) + 1, prefix, target)
473
484
  msg = "prefixes are causing a circle {}".format("|".join(prefixes.keys()))
474
485
  raise RuntimeError(msg)
475
- prefixes[prefix] = target
476
- target = target.discover_exe(cache, prefix=prefix, exact=False)
486
+ prefixes[prefix_key] = target
487
+ target = target.discover_exe(cache, prefix=prefix, exact=False, env=env)
477
488
  if target.executable != target.system_executable:
478
- resolved = cls.from_exe(target.system_executable, cache)
489
+ resolved = cls.from_exe(target.system_executable, cache, env=env)
479
490
  if resolved is not None:
480
491
  target = resolved
481
492
  if target.executable != start_executable:
@@ -484,7 +495,7 @@ class PythonInfo: # ruff:ignore[too-many-public-methods]
484
495
  target.executable = start_executable
485
496
  return target
486
497
 
487
- _cache_exe_discovery: ClassVar[dict[tuple[str, bool], PythonInfo]] = {}
498
+ _cache_exe_discovery: ClassVar[dict[tuple[str, bool, VersionInfo], PythonInfo]] = {}
488
499
 
489
500
  def discover_exe(
490
501
  self,
@@ -502,7 +513,7 @@ class PythonInfo: # ruff:ignore[too-many-public-methods]
502
513
  :param exact: when ``True``, require an exact version match.
503
514
  :param env: environment mapping; defaults to :data:`os.environ`.
504
515
  """
505
- key = prefix, exact
516
+ key = prefix, exact, self.version_info
506
517
  if key in self._cache_exe_discovery and prefix:
507
518
  _LOGGER.debug("discover exe from cache %s - exact %s: %r", prefix, exact, self._cache_exe_discovery[key])
508
519
  return self._cache_exe_discovery[key]
@@ -14,7 +14,7 @@ UNSUPPORTED_EXIT_CODE = 79 # first value past the sysexits.h range, so no stdli
14
14
  UNSUPPORTED_MARKER = "unsupported Python version "
15
15
 
16
16
  if __name__ == "__main__" and sys.version_info[:2] < MIN_INTERROGATE_VERSION: # pragma: no cover # needs <3.6
17
- sys.stderr.write(UNSUPPORTED_MARKER + ".".join(str(i) for i in sys.version_info[:3]))
17
+ sys.stderr.write(UNSUPPORTED_MARKER + ".".join(str(i) for i in sys.version_info[:3]) + "\n" + sys.executable)
18
18
  raise SystemExit(UNSUPPORTED_EXIT_CODE)
19
19
 
20
20
  import json
@@ -184,8 +184,13 @@ class PythonInfoCollector:
184
184
  except ImportError:
185
185
  pass
186
186
  else:
187
+ # Tk.__init__ reads profile scripts from HOME or the working directory; probing needs only library metadata.
188
+ class _TclWithoutProfile(tk.Tk):
189
+ def readprofile(self, *_args, **_kwargs): # ruff:ignore[no-self-use] # Tk override must be an instance method.
190
+ return None
191
+
187
192
  try:
188
- tcl = tk.Tcl()
193
+ tcl = _TclWithoutProfile(useTk=False)
189
194
  tcl_lib = tcl.eval("info library")
190
195
  tk_lib = PythonInfoCollector._resolve_tk_lib(tcl, tcl_lib)
191
196
  except tk.TclError:
@@ -212,9 +217,12 @@ class PythonInfoCollector:
212
217
  tk_lib = PythonInfoCollector._query_tk_library(tcl)
213
218
  if tk_lib is not None:
214
219
  return tk_lib
215
- tk_version = tcl.eval("package require Tk")
220
+ import _tkinter # ruff:ignore[import-outside-top-level,import-private-name] # novermin # linked Tk version
221
+
222
+ # Loading Tk can block on DISPLAY; the linked version is enough to locate its library.
223
+ tk_version = _tkinter.TK_VERSION
216
224
  tcl_parent = os.path.dirname(tcl_lib)
217
- for version in (tk_version, ".".join(tk_version.split(".")[:2]), tk_version.split(".")[0]):
225
+ for version in (tk_version, tk_version.split(".")[0]):
218
226
  tk_lib_path = os.path.join(tcl_parent, "tk{}".format(version))
219
227
  if os.path.isdir(tk_lib_path) and os.path.exists(os.path.join(tk_lib_path, "tk.tcl")):
220
228
  return tk_lib_path
@@ -210,6 +210,14 @@ class SimpleSpecifier:
210
210
  return str(candidate) == str(self.version)
211
211
  if self.operator == "~=":
212
212
  return self._check_compatible_release(candidate)
213
+ # PEP 440 excludes prereleases of a final release named by an exclusive upper bound.
214
+ if (
215
+ self.operator == "<"
216
+ and candidate.pre_type is not None
217
+ and self.version.pre_type is None
218
+ and candidate.release == self.version.release
219
+ ):
220
+ return False
213
221
  cmp_ops = {
214
222
  "==": operator.eq,
215
223
  "!=": operator.ne,
@@ -0,0 +1,51 @@
1
+ """Cancel a blocked query pipe read on Windows."""
2
+
3
+ from __future__ import annotations
4
+
5
+ from ctypes import WinDLL, WinError, get_last_error, wintypes # ty: ignore[unresolved-import] # Windows-only APIs
6
+ from time import monotonic
7
+ from typing import TYPE_CHECKING, Final
8
+
9
+ if TYPE_CHECKING:
10
+ from threading import Thread
11
+
12
+
13
+ def stop_query_reader(reader: Thread) -> None:
14
+ deadline = monotonic() + 1
15
+ while reader.is_alive() and monotonic() < deadline:
16
+ if (thread_id := reader.native_id) is not None:
17
+ try:
18
+ _cancel_synchronous_io(thread_id)
19
+ except OSError:
20
+ if reader.is_alive():
21
+ raise
22
+ reader.join(0.05)
23
+ if reader.is_alive():
24
+ msg = "query output reader did not stop"
25
+ raise TimeoutError(msg)
26
+
27
+
28
+ def _cancel_synchronous_io(thread_id: int) -> None:
29
+ error_not_found: Final[int] = 1168
30
+ kernel = WinDLL("kernel32", use_last_error=True)
31
+ open_thread = kernel.OpenThread
32
+ open_thread.argtypes = (wintypes.DWORD, wintypes.BOOL, wintypes.DWORD)
33
+ open_thread.restype = wintypes.HANDLE
34
+ cancel = kernel.CancelSynchronousIo
35
+ cancel.argtypes = (wintypes.HANDLE,)
36
+ cancel.restype = wintypes.BOOL
37
+ close = kernel.CloseHandle
38
+ close.argtypes = (wintypes.HANDLE,)
39
+ close.restype = wintypes.BOOL
40
+
41
+ if not (handle := open_thread(0x0001, wintypes.BOOL(0), thread_id)):
42
+ raise WinError(get_last_error())
43
+ try:
44
+ if not cancel(handle) and (error := get_last_error()) != error_not_found:
45
+ raise WinError(error)
46
+ finally:
47
+ if not close(handle):
48
+ raise WinError(get_last_error())
49
+
50
+
51
+ __all__ = ["stop_query_reader"]
@@ -8,6 +8,7 @@ import re
8
8
  import sys
9
9
  import winreg
10
10
  from logging import basicConfig, getLogger
11
+ from pathlib import PureWindowsPath
11
12
  from typing import TYPE_CHECKING, Any, Final
12
13
 
13
14
  if TYPE_CHECKING:
@@ -136,12 +137,16 @@ def load_exe(hive_name: str, company: str, company_key: Any, tag: str) -> tuple[
136
137
 
137
138
 
138
139
  def _resolve_exe(ip_key: Any, key_path: str) -> str | None: # ruff:ignore[any-type]
139
- if (exe := get_value(ip_key, "ExecutablePath")) is not None:
140
- return exe
141
- if (ip := get_value(ip_key, None)) is None:
142
- msg(key_path, "no ExecutablePath or default for it")
140
+ if (exe := get_value(ip_key, "ExecutablePath")) is None:
141
+ if (exe := get_value(ip_key, None)) is None:
142
+ msg(key_path, "no ExecutablePath or default for it")
143
+ return None
144
+ if isinstance(exe, str):
145
+ exe = os.path.join(exe, "python.exe")
146
+ if not isinstance(exe, str) or not PureWindowsPath(exe).is_absolute():
147
+ msg(key_path, f"expected an absolute executable path, got {exe!r}")
143
148
  return None
144
- return os.path.join(ip, "python.exe")
149
+ return exe
145
150
 
146
151
 
147
152
  def load_arch_data(hive_name: str, company: str, tag: str, tag_key: Any, default_arch: int) -> int | None: # ruff:ignore[any-type]
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.5
2
2
  Name: python-discovery
3
- Version: 1.9.1
3
+ Version: 1.9.2
4
4
  Import-Name: python_discovery
5
5
  Summary: Python interpreter discovery
6
6
  Project-URL: Changelog, https://github.com/tox-dev/python-discovery/blob/main/docs/changelog.rst
@@ -39,6 +39,8 @@ Description-Content-Type: text/markdown
39
39
  [![Downloads](https://static.pepy.tech/badge/python-discovery/month)](https://pepy.tech/project/python-discovery)
40
40
  [![check](https://github.com/tox-dev/python-discovery/actions/workflows/check.yaml/badge.svg)](https://github.com/tox-dev/python-discovery/actions/workflows/check.yaml)
41
41
  [![Documentation Status](https://readthedocs.org/projects/python-discovery/badge/?version=latest)](https://python-discovery.readthedocs.io/en/latest/?badge=latest)
42
+ [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/tox-dev/python-discovery/badge)](https://scorecard.dev/viewer/?uri=github.com/tox-dev/python-discovery)
43
+ [![OpenSSF Best Practices](https://www.bestpractices.dev/projects/16262/badge)](https://www.bestpractices.dev/projects/16262)
42
44
 
43
45
  ## What is python-discovery?
44
46
 
@@ -0,0 +1,18 @@
1
+ python_discovery/__init__.py,sha256=BV4pKMWDAK_3pU8o2hYvtL30WKs_wTzIBRuFV7nUaug,852
2
+ python_discovery/_cache.py,sha256=HVGs7H0p-iee2TESXUUn-L5Sv4Sdb0b3r-1JQdGNchQ,8446
3
+ python_discovery/_cached_py_info.py,sha256=F9lKdba0pxJB6Pczuh-MtVdLrklvqrKwzLovnPijJd8,17117
4
+ python_discovery/_compat.py,sha256=iqxGuhK9rPaiui80G1H1KrweoMJ16gyLYEmUrSXrp5c,709
5
+ python_discovery/_discovery.py,sha256=VXw4ZTSM0GIUOIPEDFcOrurjqRF8HC6eRxB36PNB8_o,25030
6
+ python_discovery/_py_info.py,sha256=jci7XqbmcPsfZitkLBIMYbC9iDz48sXky1or-q8L6qo,28158
7
+ python_discovery/_py_info_collect.py,sha256=DEUo5hNXwjxchbYppyQEuNZ627jCukB9XmtCdIIRN7Y,17928
8
+ python_discovery/_py_spec.py,sha256=s76yM2zbrKdvwhaDlPyUo6ERKkn2MldRNydPZucNvOM,12154
9
+ python_discovery/_specifier.py,sha256=bv2o_ft2Ak2tKjQblncWjKgCW3Hg4RocTebz9Jyovac,10690
10
+ python_discovery/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
11
+ python_discovery/_windows/__init__.py,sha256=qthcyGh36b3WkeSbZ4ECRRYLbCOCaQu5X_DRZ98tXfk,315
12
+ python_discovery/_windows/_cancel_io.py,sha256=aL1FxCqv01fYb56SI_TvFyRDcb_zpCcU6oMj330IRio,1689
13
+ python_discovery/_windows/_pep514.py,sha256=VLXB7LXaKfqOKRz2IklZOf4tW-NE0F9cEKRQYV4eyRM,8279
14
+ python_discovery/_windows/_propose.py,sha256=EE-N-BiNgrFU9mQ34SkoF5gRaNjtspghssQxT9uRQi0,1756
15
+ python_discovery-1.9.2.dist-info/METADATA,sha256=hjQSjjgj_wiXHip7765qcZeoAjY9wjh30gxiYgv5lPw,4235
16
+ python_discovery-1.9.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
17
+ python_discovery-1.9.2.dist-info/licenses/LICENSE,sha256=kOJeH68qSq6o2V7o5_VziwUqGswMnFgGgQH5Mahr1Yg,1023
18
+ python_discovery-1.9.2.dist-info/RECORD,,
@@ -1,17 +0,0 @@
1
- python_discovery/__init__.py,sha256=BV4pKMWDAK_3pU8o2hYvtL30WKs_wTzIBRuFV7nUaug,852
2
- python_discovery/_cache.py,sha256=svmG2GzUQzd2xTjAbm2eX1CKxxGAglfv4kxaPuxwPIA,5147
3
- python_discovery/_cached_py_info.py,sha256=15P5_TODxkZCkNfD2Uk5dtPxGf0Nea_aWm2N7uY9zbY,12059
4
- python_discovery/_compat.py,sha256=iqxGuhK9rPaiui80G1H1KrweoMJ16gyLYEmUrSXrp5c,709
5
- python_discovery/_discovery.py,sha256=4a-fRJsy6a1x__0LiiavTmQula5kN2-MnBj3fR-FKJk,23294
6
- python_discovery/_py_info.py,sha256=uP3fWpLy_N4HSIzTFQxEyxSkUBusZy-qX3Pp3VJGVg4,27442
7
- python_discovery/_py_info_collect.py,sha256=k9P4JzNkvW9iw37teeu7L6Y27ytWTnvWiK47B3gm5xg,17390
8
- python_discovery/_py_spec.py,sha256=s76yM2zbrKdvwhaDlPyUo6ERKkn2MldRNydPZucNvOM,12154
9
- python_discovery/_specifier.py,sha256=9sMnJs7FTfIIduTCKKTA7Lk7onARqwkG_zzFIqgj0xs,10364
10
- python_discovery/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
11
- python_discovery/_windows/__init__.py,sha256=qthcyGh36b3WkeSbZ4ECRRYLbCOCaQu5X_DRZ98tXfk,315
12
- python_discovery/_windows/_pep514.py,sha256=Vhxe-3hETFIXQrekLqOHmzG5eq5moeR8b0dCS80zbBg,8026
13
- python_discovery/_windows/_propose.py,sha256=EE-N-BiNgrFU9mQ34SkoF5gRaNjtspghssQxT9uRQi0,1756
14
- python_discovery-1.9.1.dist-info/METADATA,sha256=6xq9g-xC6bvsDbWc0CrFmdrq4uv519kMstNNZ_bdAO4,3937
15
- python_discovery-1.9.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
16
- python_discovery-1.9.1.dist-info/licenses/LICENSE,sha256=kOJeH68qSq6o2V7o5_VziwUqGswMnFgGgQH5Mahr1Yg,1023
17
- python_discovery-1.9.1.dist-info/RECORD,,