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

0.0

/src/python/pants/bsp/spec/lifecycle.py

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

from dataclasses import dataclass
from typing import Any

from pants.bsp.spec.base import Uri
from pants.bsp.utils import freeze_json


@dataclass(frozen=True)
class BuildClientCapabilities:
    # The languages that this client supports.
    # The ID strings for each language are defined in the LSP.
    # The server must never respond with build targets for other
    # languages than those that appear in this list.
    language_ids: tuple[str, ...]

    @classmethod
    def from_json_dict(cls, d):
        return cls(language_ids=tuple(d.get("languageIds", [])))

    def to_json_dict(self):
        return {
            "languageIds": self.language_ids,
        }


@dataclass(frozen=True)
class InitializeBuildParams:
    # Name of the client
    display_name: str

    # The version of the client
    version: str

    # The BSP version that the client speaks
    bsp_version: str

    # The rootUri of the workspace
    root_uri: Uri

    # The capabilities of the client
    capabilities: BuildClientCapabilities

    # Additional metadata about the client
    data: Any | None

    @classmethod
    def from_json_dict(cls, d):
        return cls(
            display_name=d["displayName"],
            version=d["version"],
            bsp_version=d["bspVersion"],
            root_uri=d["rootUri"],
            capabilities=BuildClientCapabilities.from_json_dict(d["capabilities"]),
            data=freeze_json(d.get("data")),
        )

    def to_json_dict(self):
        result = {
            "displayName": self.display_name,
            "version": self.version,
            "bspVersion": self.bsp_version,
            "rootUri": self.root_uri,
            "capabilities": self.capabilities.to_json_dict(),
        }
        if self.data is not None:
            result["data"] = self.data
        return result


@dataclass(frozen=True)
class CompileProvider:
    language_ids: tuple[str, ...]

    @classmethod
    def from_json_dict(cls, d):
        return cls(language_ids=tuple(d.get("languageIds", [])))

    def to_json_dict(self):
        return {
            "languageIds": self.language_ids,
        }


@dataclass(frozen=True)
class RunProvider:
    language_ids: tuple[str, ...]

    @classmethod
    def from_json_dict(cls, d):
        return cls(language_ids=tuple(d.get("languageIds", [])))

    def to_json_dict(self):
        return {
            "languageIds": self.language_ids,
        }


@dataclass(frozen=True)
class DebugProvider:
    language_ids: tuple[str, ...]

    @classmethod
    def from_json_dict(cls, d):
        return cls(language_ids=tuple(d.get("languageIds", [])))

    def to_json_dict(self):
        return {
            "languageIds": self.language_ids,
        }


@dataclass(frozen=True)
class TestProvider:
    language_ids: tuple[str, ...]

    @classmethod
    def from_json_dict(cls, d):
        return cls(language_ids=tuple(d.get("languageIds", [])))

    def to_json_dict(self):
        return {
            "languageIds": self.language_ids,
        }


@dataclass(frozen=True)
class BuildServerCapabilities:
    # The languages the server supports compilation via method buildTarget/compile.
    compile_provider: CompileProvider | None

    # The languages the server supports test execution via method buildTarget/test
    test_provider: TestProvider | None

    # The languages the server supports run via method buildTarget/run
    run_provider: RunProvider | None

    # The languages the server supports debugging via method debugSession/start
    debug_provider: DebugProvider | None

    # The server can provide a list of targets that contain a
    # single text document via the method buildTarget/inverseSources
    inverse_sources_provider: bool | None

    # The server provides sources for library dependencies
    # via method buildTarget/dependencySources
    dependency_sources_provider: bool | None

    # The server can provide a list of dependency modules (libraries with meta information)
    # via method buildTarget/dependencyModules
    dependency_modules_provider: bool | None

    # The server provides all the resource dependencies
    # via method buildTarget/resources
    resources_provider: bool | None

    # Reloading the build state through workspace/reload is supported
    can_reload: bool | None

    # The server sends notifications to the client on build
    # target change events via buildTarget/didChange
    build_target_changed_provider: bool | None

    @classmethod
    def from_json_dict(cls, d):
        return cls(
            compile_provider=(
                CompileProvider.from_json_dict(d["compileProvider"])
                if "compileProvider" in d
                else None
            ),
            test_provider=(
                TestProvider.from_json_dict(d["testProvider"]) if "testProvider" in d else None
            ),
            run_provider=(
                RunProvider.from_json_dict(d["runProvider"]) if "runProvider" in d else None
            ),
            debug_provider=(
                DebugProvider.from_json_dict(d["debugProvider"]) if "debugProvider" in d else None
            ),
            inverse_sources_provider=d.get("inverseSourcesProvider"),
            dependency_sources_provider=d.get("dependencySourcesProvider"),
            dependency_modules_provider=d.get("dependencyModulesProvider"),
            resources_provider=d.get("resourcesProvider"),
            can_reload=d.get("canReload"),
            build_target_changed_provider=d.get("buildTargetChangedProvider"),
        )

    def to_json_dict(self):
        result = {}
        if self.compile_provider is not None:
            result["compileProvider"] = self.compile_provider.to_json_dict()
        if self.test_provider is not None:
            result["testProvider"] = self.test_provider.to_json_dict()
        if self.run_provider is not None:
            result["runProvider"] = self.run_provider.to_json_dict()
        if self.debug_provider is not None:
            result["debugProvider"] = self.debug_provider.to_json_dict()
        if self.inverse_sources_provider is not None:
            result["inverseSourcesProvider"] = self.inverse_sources_provider
        if self.dependency_sources_provider is not None:
            result["dependencySourcesProvider"] = self.dependency_sources_provider
        if self.dependency_modules_provider is not None:
            result["dependencyModulesProvider"] = self.dependency_modules_provider
        if self.resources_provider is not None:
            result["resourcesProvider"] = self.resources_provider
        if self.can_reload is not None:
            result["canReload"] = self.can_reload
        if self.build_target_changed_provider is not None:
            result["buildTargetChangedProvider"] = self.build_target_changed_provider
        return result


@dataclass(frozen=True)
class InitializeBuildResult:
    # Name of the server
    display_name: str

    # The version of the server
    version: str

    # The BSP version that the server speaks
    bsp_version: str

    # The capabilities of the build server
    capabilities: BuildServerCapabilities

    # Additional metadata about the server
    data: Any | None

    @classmethod
    def from_json_dict(cls, d):
        return cls(
            display_name=d["displayName"],
            version=d["version"],
            bsp_version=d["bspVersion"],
            capabilities=BuildServerCapabilities.from_json_dict(d["capabilities"]),
            data=d.get("data"),
        )

    def to_json_dict(self):
        result = {
            "displayName": self.display_name,
            "version": self.version,
            "bspVersion": self.bsp_version,
            "capabilities": self.capabilities.to_json_dict(),
        }
        if self.data is not None:
            # TODO: Figure out whether to encode/decode data in a generic manner.
            result["data"] = self.data
        return result

1	# Copyright 2022 Pants project contributors (see CONTRIBUTORS.md).
2	# Licensed under the Apache License, Version 2.0 (see LICENSE).
3	from __future__ import annotations	×
4
5	from dataclasses import dataclass	×
6	from typing import Any	×
7
8	from pants.bsp.spec.base import Uri	×
9	from pants.bsp.utils import freeze_json	×
10
11
12	@dataclass(frozen=True)	×
13	class BuildClientCapabilities:	×
14	# The languages that this client supports.
15	# The ID strings for each language are defined in the LSP.
16	# The server must never respond with build targets for other
17	# languages than those that appear in this list.
18	language_ids: tuple[str, ...]	×
19
20	@classmethod	×
21	def from_json_dict(cls, d):	×
22	return cls(language_ids=tuple(d.get("languageIds", [])))	×
23
24	def to_json_dict(self):	×
25	return {	×
26	"languageIds": self.language_ids,
27	}
28
29
30	@dataclass(frozen=True)	×
31	class InitializeBuildParams:	×
32	# Name of the client
33	display_name: str	×
34
35	# The version of the client
36	version: str	×
37
38	# The BSP version that the client speaks
39	bsp_version: str	×
40
41	# The rootUri of the workspace
42	root_uri: Uri	×
43
44	# The capabilities of the client
45	capabilities: BuildClientCapabilities	×
46
47	# Additional metadata about the client
48	data: Any \| None	×
49
50	@classmethod	×
51	def from_json_dict(cls, d):	×
52	return cls(	×
53	display_name=d["displayName"],
54	version=d["version"],
55	bsp_version=d["bspVersion"],
56	root_uri=d["rootUri"],
57	capabilities=BuildClientCapabilities.from_json_dict(d["capabilities"]),
58	data=freeze_json(d.get("data")),
59	)
60
61	def to_json_dict(self):	×
62	result = {	×
63	"displayName": self.display_name,
64	"version": self.version,
65	"bspVersion": self.bsp_version,
66	"rootUri": self.root_uri,
67	"capabilities": self.capabilities.to_json_dict(),
68	}
69	if self.data is not None:	×
70	result["data"] = self.data	×
71	return result	×
72
73
74	@dataclass(frozen=True)	×
75	class CompileProvider:	×
76	language_ids: tuple[str, ...]	×
77
78	@classmethod	×
79	def from_json_dict(cls, d):	×
80	return cls(language_ids=tuple(d.get("languageIds", [])))	×
81
82	def to_json_dict(self):	×
83	return {	×
84	"languageIds": self.language_ids,
85	}
86
87
88	@dataclass(frozen=True)	×
89	class RunProvider:	×
90	language_ids: tuple[str, ...]	×
91
92	@classmethod	×
93	def from_json_dict(cls, d):	×
94	return cls(language_ids=tuple(d.get("languageIds", [])))	×
95
96	def to_json_dict(self):	×
97	return {	×
98	"languageIds": self.language_ids,
99	}
100
101
102	@dataclass(frozen=True)	×
103	class DebugProvider:	×
104	language_ids: tuple[str, ...]	×
105
106	@classmethod	×
107	def from_json_dict(cls, d):	×
108	return cls(language_ids=tuple(d.get("languageIds", [])))	×
109
110	def to_json_dict(self):	×
111	return {	×
112	"languageIds": self.language_ids,
113	}
114
115
116	@dataclass(frozen=True)	×
117	class TestProvider:	×
118	language_ids: tuple[str, ...]	×
119
120	@classmethod	×
121	def from_json_dict(cls, d):	×
122	return cls(language_ids=tuple(d.get("languageIds", [])))	×
123
124	def to_json_dict(self):	×
125	return {	×
126	"languageIds": self.language_ids,
127	}
128
129
130	@dataclass(frozen=True)	×
131	class BuildServerCapabilities:	×
132	# The languages the server supports compilation via method buildTarget/compile.
133	compile_provider: CompileProvider \| None	×
134
135	# The languages the server supports test execution via method buildTarget/test
136	test_provider: TestProvider \| None	×
137
138	# The languages the server supports run via method buildTarget/run
139	run_provider: RunProvider \| None	×
140
141	# The languages the server supports debugging via method debugSession/start
142	debug_provider: DebugProvider \| None	×
143
144	# The server can provide a list of targets that contain a
145	# single text document via the method buildTarget/inverseSources
146	inverse_sources_provider: bool \| None	×
147
148	# The server provides sources for library dependencies
149	# via method buildTarget/dependencySources
150	dependency_sources_provider: bool \| None	×
151
152	# The server can provide a list of dependency modules (libraries with meta information)
153	# via method buildTarget/dependencyModules
154	dependency_modules_provider: bool \| None	×
155
156	# The server provides all the resource dependencies
157	# via method buildTarget/resources
158	resources_provider: bool \| None	×
159
160	# Reloading the build state through workspace/reload is supported
161	can_reload: bool \| None	×
162
163	# The server sends notifications to the client on build
164	# target change events via buildTarget/didChange
165	build_target_changed_provider: bool \| None	×
166
167	@classmethod	×
168	def from_json_dict(cls, d):	×
169	return cls(	×
170	compile_provider=(
171	CompileProvider.from_json_dict(d["compileProvider"])
172	if "compileProvider" in d
173	else None
174	),
175	test_provider=(
176	TestProvider.from_json_dict(d["testProvider"]) if "testProvider" in d else None
177	),
178	run_provider=(
179	RunProvider.from_json_dict(d["runProvider"]) if "runProvider" in d else None
180	),
181	debug_provider=(
182	DebugProvider.from_json_dict(d["debugProvider"]) if "debugProvider" in d else None
183	),
184	inverse_sources_provider=d.get("inverseSourcesProvider"),
185	dependency_sources_provider=d.get("dependencySourcesProvider"),
186	dependency_modules_provider=d.get("dependencyModulesProvider"),
187	resources_provider=d.get("resourcesProvider"),
188	can_reload=d.get("canReload"),
189	build_target_changed_provider=d.get("buildTargetChangedProvider"),
190	)
191
192	def to_json_dict(self):	×
193	result = {}	×
194	if self.compile_provider is not None:	×
195	result["compileProvider"] = self.compile_provider.to_json_dict()	×
196	if self.test_provider is not None:	×
197	result["testProvider"] = self.test_provider.to_json_dict()	×
198	if self.run_provider is not None:	×
199	result["runProvider"] = self.run_provider.to_json_dict()	×
200	if self.debug_provider is not None:	×
201	result["debugProvider"] = self.debug_provider.to_json_dict()	×
202	if self.inverse_sources_provider is not None:	×
203	result["inverseSourcesProvider"] = self.inverse_sources_provider	×
204	if self.dependency_sources_provider is not None:	×
205	result["dependencySourcesProvider"] = self.dependency_sources_provider	×
206	if self.dependency_modules_provider is not None:	×
207	result["dependencyModulesProvider"] = self.dependency_modules_provider	×
208	if self.resources_provider is not None:	×
209	result["resourcesProvider"] = self.resources_provider	×
210	if self.can_reload is not None:	×
211	result["canReload"] = self.can_reload	×
212	if self.build_target_changed_provider is not None:	×
213	result["buildTargetChangedProvider"] = self.build_target_changed_provider	×
214	return result	×
215
216
217	@dataclass(frozen=True)	×
218	class InitializeBuildResult:	×
219	# Name of the server
220	display_name: str	×
221
222	# The version of the server
223	version: str	×
224
225	# The BSP version that the server speaks
226	bsp_version: str	×
227
228	# The capabilities of the build server
229	capabilities: BuildServerCapabilities	×
230
231	# Additional metadata about the server
232	data: Any \| None	×
233
234	@classmethod	×
235	def from_json_dict(cls, d):	×
236	return cls(	×
237	display_name=d["displayName"],
238	version=d["version"],
239	bsp_version=d["bspVersion"],
240	capabilities=BuildServerCapabilities.from_json_dict(d["capabilities"]),
241	data=d.get("data"),
242	)
243
244	def to_json_dict(self):	×
245	result = {	×
246	"displayName": self.display_name,
247	"version": self.version,
248	"bspVersion": self.bsp_version,
249	"capabilities": self.capabilities.to_json_dict(),
250	}
251	if self.data is not None:	×
252	# TODO: Figure out whether to encode/decode data in a generic manner.
253	result["data"] = self.data	×
254	return result	×

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