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/backend/python/macros/pipenv_requirements.py

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

from __future__ import annotations

import json

from pants.backend.python.macros.common_fields import (
    ModuleMappingField,
    RequirementsOverrideField,
    TypeStubsModuleMappingField,
)
from pants.backend.python.macros.common_requirements_rule import _generate_requirements
from pants.backend.python.subsystems.setup import PythonSetup
from pants.backend.python.target_types import PythonRequirementResolveField, PythonRequirementTarget
from pants.engine.rules import collect_rules, rule
from pants.engine.target import (
    COMMON_TARGET_FIELDS,
    GeneratedTargets,
    GenerateTargetsRequest,
    SingleSourceField,
    TargetGenerator,
)
from pants.engine.unions import UnionMembership, UnionRule
from pants.util.logging import LogLevel
from pants.util.pip_requirement import PipRequirement


class PipenvSourceField(SingleSourceField):
    default = "Pipfile.lock"
    required = False


class PipenvRequirementsTargetGenerator(TargetGenerator):
    alias = "pipenv_requirements"
    help = "Generate a `python_requirement` for each entry in `Pipenv.lock`."
    generated_target_cls = PythonRequirementTarget
    # Note that this does not have a `dependencies` field.
    core_fields = (
        *COMMON_TARGET_FIELDS,
        ModuleMappingField,
        TypeStubsModuleMappingField,
        PipenvSourceField,
        RequirementsOverrideField,
    )
    copied_fields = COMMON_TARGET_FIELDS
    moved_fields = (PythonRequirementResolveField,)


class GenerateFromPipenvRequirementsRequest(GenerateTargetsRequest):
    generate_from = PipenvRequirementsTargetGenerator


# TODO(#10655): add support for PEP 440 direct references (aka VCS style).
# TODO(#10655): differentiate between Pipfile vs. Pipfile.lock.
@rule(desc="Generate `python_requirement` targets from Pipfile.lock", level=LogLevel.DEBUG)
async def generate_from_pipenv_requirements(
    request: GenerateFromPipenvRequirementsRequest,
    union_membership: UnionMembership,
    python_setup: PythonSetup,
) -> GeneratedTargets:
    result = await _generate_requirements(
        request,
        union_membership,
        python_setup,
        parse_requirements_callback=parse_pipenv_requirements,
    )
    return GeneratedTargets(request.generator, result)


def parse_pipenv_requirements(
    file_contents: bytes, file_path: str = ""
) -> tuple[PipRequirement, ...]:
    lock_info = json.loads(file_contents)

    def _parse_pipenv_requirement(raw_req: str, info: dict) -> PipRequirement:
        if info.get("extras"):
            raw_req += f"[{','.join(info['extras'])}]"
        raw_req += info.get("version", "")
        if info.get("markers"):
            raw_req += f";{info['markers']}"

        return PipRequirement.parse(raw_req)

    return tuple(
        _parse_pipenv_requirement(req, info)
        for req, info in {**lock_info.get("default", {}), **lock_info.get("develop", {})}.items()
    )


def rules():
    return (
        *collect_rules(),
        UnionRule(GenerateTargetsRequest, GenerateFromPipenvRequirementsRequest),
    )

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	×
5
6	import json	×
7
8	from pants.backend.python.macros.common_fields import (	×
9	ModuleMappingField,
10	RequirementsOverrideField,
11	TypeStubsModuleMappingField,
12	)
13	from pants.backend.python.macros.common_requirements_rule import _generate_requirements	×
14	from pants.backend.python.subsystems.setup import PythonSetup	×
15	from pants.backend.python.target_types import PythonRequirementResolveField, PythonRequirementTarget	×
16	from pants.engine.rules import collect_rules, rule	×
17	from pants.engine.target import (	×
18	COMMON_TARGET_FIELDS,
19	GeneratedTargets,
20	GenerateTargetsRequest,
21	SingleSourceField,
22	TargetGenerator,
23	)
24	from pants.engine.unions import UnionMembership, UnionRule	×
25	from pants.util.logging import LogLevel	×
26	from pants.util.pip_requirement import PipRequirement	×
27
28
29	class PipenvSourceField(SingleSourceField):	×
30	default = "Pipfile.lock"	×
31	required = False	×
32
33
34	class PipenvRequirementsTargetGenerator(TargetGenerator):	×
35	alias = "pipenv_requirements"	×
36	help = "Generate a `python_requirement` for each entry in `Pipenv.lock`."	×
37	generated_target_cls = PythonRequirementTarget	×
38	# Note that this does not have a `dependencies` field.
39	core_fields = (	×
40	*COMMON_TARGET_FIELDS,
41	ModuleMappingField,
42	TypeStubsModuleMappingField,
43	PipenvSourceField,
44	RequirementsOverrideField,
45	)
46	copied_fields = COMMON_TARGET_FIELDS	×
47	moved_fields = (PythonRequirementResolveField,)	×
48
49
50	class GenerateFromPipenvRequirementsRequest(GenerateTargetsRequest):	×
51	generate_from = PipenvRequirementsTargetGenerator	×
52
53
54	# TODO(#10655): add support for PEP 440 direct references (aka VCS style).
55	# TODO(#10655): differentiate between Pipfile vs. Pipfile.lock.
56	@rule(desc="Generate `python_requirement` targets from Pipfile.lock", level=LogLevel.DEBUG)	×
57	async def generate_from_pipenv_requirements(	×
58	request: GenerateFromPipenvRequirementsRequest,
59	union_membership: UnionMembership,
60	python_setup: PythonSetup,
61	) -> GeneratedTargets:
62	result = await _generate_requirements(	×
63	request,
64	union_membership,
65	python_setup,
66	parse_requirements_callback=parse_pipenv_requirements,
67	)
68	return GeneratedTargets(request.generator, result)	×
69
70
71	def parse_pipenv_requirements(	×
72	file_contents: bytes, file_path: str = ""
73	) -> tuple[PipRequirement, ...]:
74	lock_info = json.loads(file_contents)	×
75
76	def _parse_pipenv_requirement(raw_req: str, info: dict) -> PipRequirement:	×
77	if info.get("extras"):	×
78	raw_req += f"[{','.join(info['extras'])}]"	×
79	raw_req += info.get("version", "")	×
80	if info.get("markers"):	×
81	raw_req += f";{info['markers']}"	×
82
83	return PipRequirement.parse(raw_req)	×
84
85	return tuple(	×
86	_parse_pipenv_requirement(req, info)
87	for req, info in {lock_info.get("default", {}), lock_info.get("develop", {})}.items()
88	)
89
90
91	def rules():	×
92	return (	×
93	*collect_rules(),
94	UnionRule(GenerateTargetsRequest, GenerateFromPipenvRequirementsRequest),
95	)

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