18252174847

Committed 05 Oct 2025 01:36AM UTC coverage: 43.382% (-36.9%) from 80.261%

Build # 18252174847

Build Type

push

github

Committed by

web-flow

Commit Message

run tests on mac arm (#22717)

Just doing the minimal to pull forward the x86_64 pattern.

ref #20993

Run Details

25776 of 59416 relevant lines covered (43.38%)

1.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.76

/src/python/pants/backend/python/util_rules/lockfile_diff.py

# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).

from __future__ import annotations

import itertools
import json
import logging
from collections.abc import Mapping
from dataclasses import dataclass
from typing import Any

from packaging.version import Version, parse

from pants.backend.python.util_rules.pex_requirements import (
    LoadedLockfileRequest,
    Lockfile,
    load_lockfile,
    strip_comments_from_pex_json_lockfile,
)
from pants.base.exceptions import EngineError
from pants.core.goals.generate_lockfiles import LockfileDiff, LockfilePackages, PackageName
from pants.engine.fs import Digest
from pants.engine.intrinsics import get_digest_contents
from pants.engine.rules import implicitly
from pants.util.frozendict import FrozenDict

logger = logging.getLogger(__name__)


@dataclass(frozen=True, order=True)
class PythonRequirementVersion:
    _parsed: Version

    @classmethod
    def parse(cls, version: str) -> PythonRequirementVersion:
        return cls(parse(version))

    def __str__(self) -> str:
        return str(self._parsed)

    def __getattr__(self, key: str) -> Any:
        return getattr(self._parsed, key)


def _pex_lockfile_requirements(
    lockfile_data: Mapping[str, Any] | None, path: str | None = None
) -> LockfilePackages:
    if not lockfile_data:
        return LockfilePackages({})

    try:
        # Setup generators
        locked_resolves = (
            (
                (PackageName(r["project_name"]), PythonRequirementVersion.parse(r["version"]))
                for r in resolve["locked_requirements"]
            )
            for resolve in lockfile_data["locked_resolves"]
        )
        requirements = dict(itertools.chain.from_iterable(locked_resolves))
    except KeyError as e:
        if path:
            logger.warning(f"{path}: Failed to parse lockfile: {e}")

        requirements = {}

    return LockfilePackages(requirements)


async def _parse_lockfile(lockfile: Lockfile) -> FrozenDict[str, Any] | None:
    try:
        loaded = await load_lockfile(LoadedLockfileRequest(lockfile), **implicitly())
        fc = await get_digest_contents(loaded.lockfile_digest)
        parsed = await _parse_lockfile_content(next(iter(fc)).content, lockfile.url)
        return parsed
    except EngineError:
        # May fail in case the file doesn't exist, which is expected when parsing the "old" lockfile
        # the first time a new lockfile is generated.
        return None


async def _parse_lockfile_content(content: bytes, url: str) -> FrozenDict[str, Any] | None:
    try:
        parsed_lockfile = json.loads(content)
        return FrozenDict.deep_freeze(parsed_lockfile)
    except json.JSONDecodeError as e:
        logger.debug(f"{url}: Failed to parse lockfile contents: {e}")
        return None


async def _generate_python_lockfile_diff(
    digest: Digest, resolve_name: str, path: str
) -> LockfileDiff:
    new_digest_contents = await get_digest_contents(digest)
    new_content = next(c for c in new_digest_contents if c.path == path).content
    new_content = strip_comments_from_pex_json_lockfile(new_content)
    new = await _parse_lockfile_content(new_content, path)
    old = await _parse_lockfile(
        Lockfile(
            url=path,
            url_description_of_origin="existing lockfile",
            resolve_name=resolve_name,
        )
    )
    return LockfileDiff.create(
        path=path,
        resolve_name=resolve_name,
        old=_pex_lockfile_requirements(old),
        new=_pex_lockfile_requirements(new, path),
    )

1	# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3
4	from __future__ import annotations	3✔
5
6	import itertools	3✔
7	import json	3✔
8	import logging	3✔
9	from collections.abc import Mapping	3✔
10	from dataclasses import dataclass	3✔
11	from typing import Any	3✔
12
13	from packaging.version import Version, parse	3✔
14
15	from pants.backend.python.util_rules.pex_requirements import (	3✔
16	LoadedLockfileRequest,
17	Lockfile,
18	load_lockfile,
19	strip_comments_from_pex_json_lockfile,
20	)
21	from pants.base.exceptions import EngineError	3✔
22	from pants.core.goals.generate_lockfiles import LockfileDiff, LockfilePackages, PackageName	3✔
23	from pants.engine.fs import Digest	3✔
24	from pants.engine.intrinsics import get_digest_contents	3✔
25	from pants.engine.rules import implicitly	3✔
26	from pants.util.frozendict import FrozenDict	3✔
27
28	logger = logging.getLogger(__name__)	3✔
29
30
31	@dataclass(frozen=True, order=True)	3✔
32	class PythonRequirementVersion:	3✔
33	_parsed: Version	3✔
34
35	@classmethod	3✔
36	def parse(cls, version: str) -> PythonRequirementVersion:	3✔
37	return cls(parse(version))	×
38
39	def __str__(self) -> str:	3✔
40	return str(self._parsed)	×
41
42	def __getattr__(self, key: str) -> Any:	3✔
43	return getattr(self._parsed, key)	×
44
45
46	def _pex_lockfile_requirements(	3✔
47	lockfile_data: Mapping[str, Any] \| None, path: str \| None = None
48	) -> LockfilePackages:
49	if not lockfile_data:	×
50	return LockfilePackages({})	×
51
52	try:	×
53	# Setup generators
54	locked_resolves = (	×
55	(
56	(PackageName(r["project_name"]), PythonRequirementVersion.parse(r["version"]))
57	for r in resolve["locked_requirements"]
58	)
59	for resolve in lockfile_data["locked_resolves"]
60	)
61	requirements = dict(itertools.chain.from_iterable(locked_resolves))	×
62	except KeyError as e:	×
63	if path:	×
64	logger.warning(f"{path}: Failed to parse lockfile: {e}")	×
65
66	requirements = {}	×
67
68	return LockfilePackages(requirements)	×
69
70
71	async def _parse_lockfile(lockfile: Lockfile) -> FrozenDict[str, Any] \| None:	3✔
72	try:	×
73	loaded = await load_lockfile(LoadedLockfileRequest(lockfile), **implicitly())	×
74	fc = await get_digest_contents(loaded.lockfile_digest)	×
75	parsed = await _parse_lockfile_content(next(iter(fc)).content, lockfile.url)	×
76	return parsed	×
77	except EngineError:	×
78	# May fail in case the file doesn't exist, which is expected when parsing the "old" lockfile
79	# the first time a new lockfile is generated.
80	return None	×
81
82
83	async def _parse_lockfile_content(content: bytes, url: str) -> FrozenDict[str, Any] \| None:	3✔
84	try:	×
85	parsed_lockfile = json.loads(content)	×
86	return FrozenDict.deep_freeze(parsed_lockfile)	×
87	except json.JSONDecodeError as e:	×
88	logger.debug(f"{url}: Failed to parse lockfile contents: {e}")	×
89	return None	×
90
91
92	async def _generate_python_lockfile_diff(	3✔
93	digest: Digest, resolve_name: str, path: str
94	) -> LockfileDiff:
95	new_digest_contents = await get_digest_contents(digest)	×
96	new_content = next(c for c in new_digest_contents if c.path == path).content	×
97	new_content = strip_comments_from_pex_json_lockfile(new_content)	×
98	new = await _parse_lockfile_content(new_content, path)	×
99	old = await _parse_lockfile(	×
100	Lockfile(
101	url=path,
102	url_description_of_origin="existing lockfile",
103	resolve_name=resolve_name,
104	)
105	)
106	return LockfileDiff.create(	×
107	path=path,
108	resolve_name=resolve_name,
109	old=_pex_lockfile_requirements(old),
110	new=_pex_lockfile_requirements(new, path),
111	)

pantsbuild / pants / 18252174847

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous