23173035367

Committed 17 Mar 2026 12:47AM UTC coverage: 91.371% (-1.6%) from 92.933%

Build # 23173035367

Build Type

push

github

Committed by

web-flow

Commit Message

update helm (and friends) to a recent 3.x seies (#23143)

v4 is a major breaking change, so holding off on that. (There was also
just a 3.20, but 3.19 has this reassuring series of bug fixes and was
also quite recent.)

Run Details

2 of 2 new or added lines in 2 files covered. (100.0%)

1263 existing lines in 73 files now uncovered.

86196 of 94336 relevant lines covered (91.37%)

3.87 hits per line

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

85.71

/src/python/pants/engine/internals/target_adaptor.py

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

from __future__ import annotations

import dataclasses
from dataclasses import dataclass
from typing import Any, final

from pants.build_graph.address import Address
from pants.engine.engine_aware import EngineAwareParameter
from pants.util.frozendict import FrozenDict
from pants.util.ordered_set import FrozenOrderedSet
from pants.vcs.hunk import TextBlock


@dataclass(frozen=True)
class SourceBlock:
    """Block of lines in a file.

    Lines are 1 indexed, `start` is inclusive, `end` is exclusive.

    SourceBlock is used to describe a set of source lines that are owned by a Target,
    thus it can't be empty, i.e. `start` must be less than `end`.
    """

    start: int
    end: int

    def __init__(self, start: int, end: int):
        object.__setattr__(self, "start", start)
        object.__setattr__(self, "end", end)

        self.__post_init__()

    def __post_init__(self):
        if self.start >= self.end:
            raise ValueError(f"{self.start=} must be less than {self.end=}")

    def __len__(self) -> int:
        return self.end - self.start

    def is_touched_by(self, o: TextBlock) -> bool:
        """Check if the TextBlock touches the SourceBlock.

        The function behaves similarly to range intersection check, but some edge cases are
        different. See test cases for details.
        """

        if o.count == 0:
            start = o.start + 1
            end = start
        else:
            start = o.start
            end = o.end

        if self.end < start:
            return False
        if end < self.start:
            return False
        return True

    @classmethod
    def from_text_block(cls, text_block: TextBlock) -> SourceBlock:
        """Convert (start, count) range to (start, end) range.

        Useful for unified diff conversion, see
        https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
        """
        return cls(start=text_block.start, end=text_block.start + text_block.count)


class SourceBlocks(FrozenOrderedSet[SourceBlock]):
    pass


@dataclass(frozen=True)
class TargetAdaptorRequest(EngineAwareParameter):
    """Lookup the TargetAdaptor for an Address."""

    address: Address
    description_of_origin: str = dataclasses.field(hash=False, compare=False)

    def debug_hint(self) -> str:
        return self.address.spec


@final
class TargetAdaptor:
    """A light-weight object to store target information before being converted into the Target
    API."""

    __slots__ = ("type_alias", "name", "kwargs", "description_of_origin", "origin_sources_blocks")

    def __init__(
        self,
        type_alias: str,
        name: str | None,
        __description_of_origin__: str,
        __origin_sources_blocks__: FrozenDict[str, SourceBlocks] = FrozenDict(),
        **kwargs: Any,
    ) -> None:
        self.type_alias = type_alias
        self.name = name
        try:
            self.kwargs = FrozenDict.deep_freeze(kwargs)
        except TypeError as e:
            # FrozenDict's ctor eagerly computes its hash. If some kwarg is unhashable it will
            # raise a TypeError, which we enhance with the description of origin.
            raise TypeError(f"In {__description_of_origin__}: {e}")
        self.description_of_origin = __description_of_origin__
        self.origin_sources_blocks = __origin_sources_blocks__

    def with_new_kwargs(self, **kwargs) -> TargetAdaptor:
        return TargetAdaptor(
            type_alias=self.type_alias,
            name=self.name,
            __description_of_origin__=self.description_of_origin,
            __origin_sources_blocks__=self.origin_sources_blocks,
            **kwargs,
        )

    def __repr__(self) -> str:
        maybe_blocks = f", {self.origin_sources_blocks}" if self.origin_sources_blocks else ""
        return f"TargetAdaptor(type_alias={self.type_alias}, name={self.name}, origin={self.description_of_origin}{maybe_blocks})"

    def __eq__(self, other: Any | TargetAdaptor) -> bool:
        if not isinstance(other, TargetAdaptor):
            return NotImplemented
        return (
            self.type_alias == other.type_alias
            and self.name == other.name
            and self.kwargs == other.kwargs
        )

    def __hash__(self) -> int:
        return hash((self.type_alias, self.name, self.kwargs))

    @property
    def name_explicitly_set(self) -> bool:
        return self.name is not None

1	# Copyright 2020 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3
4	from __future__ import annotations	11✔
5
6	import dataclasses	11✔
7	from dataclasses import dataclass	11✔
8	from typing import Any, final	11✔
9
10	from pants.build_graph.address import Address	11✔
11	from pants.engine.engine_aware import EngineAwareParameter	11✔
12	from pants.util.frozendict import FrozenDict	11✔
13	from pants.util.ordered_set import FrozenOrderedSet	11✔
14	from pants.vcs.hunk import TextBlock	11✔
15
16
17	@dataclass(frozen=True)	11✔
18	class SourceBlock:	11✔
19	"""Block of lines in a file.
20
21	Lines are 1 indexed, `start` is inclusive, `end` is exclusive.
22
23	SourceBlock is used to describe a set of source lines that are owned by a Target,
24	thus it can't be empty, i.e. `start` must be less than `end`.
25	"""
26
27	start: int	11✔
28	end: int	11✔
29
30	def __init__(self, start: int, end: int):	11✔
31	object.__setattr__(self, "start", start)	2✔
32	object.__setattr__(self, "end", end)	2✔
33
34	self.__post_init__()	2✔
35
36	def __post_init__(self):	11✔
37	if self.start >= self.end:	2✔
38	raise ValueError(f"{self.start=} must be less than {self.end=}")	×
39
40	def __len__(self) -> int:	11✔
41	return self.end - self.start	×
42
43	def is_touched_by(self, o: TextBlock) -> bool:	11✔
44	"""Check if the TextBlock touches the SourceBlock.
45
46	The function behaves similarly to range intersection check, but some edge cases are
47	different. See test cases for details.
48	"""
49
50	if o.count == 0:	1✔
51	start = o.start + 1	1✔
52	end = start	1✔
53	else:
54	start = o.start	1✔
55	end = o.end	1✔
56
57	if self.end < start:	1✔
58	return False	1✔
59	if end < self.start:	1✔
60	return False	1✔
61	return True	1✔
62
63	@classmethod	11✔
64	def from_text_block(cls, text_block: TextBlock) -> SourceBlock:	11✔
65	"""Convert (start, count) range to (start, end) range.
66
67	Useful for unified diff conversion, see
68	https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
69	"""
70	return cls(start=text_block.start, end=text_block.start + text_block.count)	×
71
72
73	class SourceBlocks(FrozenOrderedSet[SourceBlock]):	11✔
74	pass	11✔
75
76
77	@dataclass(frozen=True)	11✔
78	class TargetAdaptorRequest(EngineAwareParameter):	11✔
79	"""Lookup the TargetAdaptor for an Address."""
80
81	address: Address	11✔
82	description_of_origin: str = dataclasses.field(hash=False, compare=False)	11✔
83
84	def debug_hint(self) -> str:	11✔
85	return self.address.spec	×
86
87
88	@final	11✔
89	class TargetAdaptor:	11✔
90	"""A light-weight object to store target information before being converted into the Target
91	API."""
92
93	__slots__ = ("type_alias", "name", "kwargs", "description_of_origin", "origin_sources_blocks")	11✔
94
95	def __init__(	11✔
96	self,
97	type_alias: str,
98	name: str \| None,
99	__description_of_origin__: str,
100	__origin_sources_blocks__: FrozenDict[str, SourceBlocks] = FrozenDict(),
101	**kwargs: Any,
102	) -> None:
103	self.type_alias = type_alias	11✔
104	self.name = name	11✔
105	try:	11✔
106	self.kwargs = FrozenDict.deep_freeze(kwargs)	11✔
107	except TypeError as e:	×
108	# FrozenDict's ctor eagerly computes its hash. If some kwarg is unhashable it will
109	# raise a TypeError, which we enhance with the description of origin.
110	raise TypeError(f"In {__description_of_origin__}: {e}")	×
111	self.description_of_origin = __description_of_origin__	11✔
112	self.origin_sources_blocks = __origin_sources_blocks__	11✔
113
114	def with_new_kwargs(self, **kwargs) -> TargetAdaptor:	11✔
UNCOV 115	return TargetAdaptor(	×
116	type_alias=self.type_alias,
117	name=self.name,
118	__description_of_origin__=self.description_of_origin,
119	__origin_sources_blocks__=self.origin_sources_blocks,
120	**kwargs,
121	)
122
123	def __repr__(self) -> str:	11✔
124	maybe_blocks = f", {self.origin_sources_blocks}" if self.origin_sources_blocks else ""	×
125	return f"TargetAdaptor(type_alias={self.type_alias}, name={self.name}, origin={self.description_of_origin}{maybe_blocks})"	×
126
127	def __eq__(self, other: Any \| TargetAdaptor) -> bool:	11✔
128	if not isinstance(other, TargetAdaptor):	11✔
129	return NotImplemented	×
130	return (	11✔
131	self.type_alias == other.type_alias
132	and self.name == other.name
133	and self.kwargs == other.kwargs
134	)
135
136	def __hash__(self) -> int:	11✔
137	return hash((self.type_alias, self.name, self.kwargs))	11✔
138
139	@property	11✔
140	def name_explicitly_set(self) -> bool:	11✔
141	return self.name is not None	11✔

pantsbuild / pants / 23173035367

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