def is_ownable_target(tgt: Target, union_membership: UnionMembership) -> bool:
return (
# Note that we check for a PythonProvides field so that a python_distribution
# target can be owned (by itself). This is so that if there are any 3rdparty
# requirements directly on the python_distribution target, we apply them to the dist.
# This isn't particularly useful (3rdparty requirements should be on the python_library
# that consumes them)... but users may expect it to work anyway.
tgt.has_field(PythonProvidesField) or tgt.has_field(PythonSources)
or tgt.has_field(ResourcesSources)
or tgt.get(Sources).can_generate(PythonSources, union_membership))
def opt_out(cls, tgt: Target) -> bool:
if tgt.get(SkipPythonTestsField).value:
return True
if not tgt.address.is_file_target:
return False
file_name = PurePath(tgt.address.filename)
return file_name.name == "conftest.py" or file_name.suffix == ".pyi"
def is_compatible(target: Target) -> bool:
return (
# Is directly applicable.
any(fs.is_applicable(target) for fs in impl.field_sets) or
# Is applicable via generated sources.
any(target.has_field(g) for g in generator_sources) or
# Is applicable via a generator.
(isinstance(target, TargetFilesGenerator)
and any(field in target.generated_target_cls.core_fields
for field in generator_sources)))
def create(cls, tgt: Target) -> "BinaryConfiguration":
all_expected_fields: Dict[str, Type[Field]] = {
dataclass_field.name: dataclass_field.type
for dataclass_field in dataclasses.fields(cls)
if issubclass(dataclass_field.type, Field)
}
return cls( # type: ignore[call-arg]
address=tgt.address,
**{
dataclass_field_name: (
tgt[field_cls] if field_cls in cls.required_fields else tgt.get(field_cls)
)
for dataclass_field_name, field_cls in all_expected_fields.items()
},
)
def is_ownable_target(tgt: Target, union_membership: UnionMembership) -> bool:
return (
# Note that we check for a PythonProvides field so that a python_distribution
# target can be owned (by itself). This is so that if there are any 3rdparty
# requirements directly on the python_distribution target, we apply them to the dist.
# This isn't particularly useful (3rdparty requirements should be on the python_sources
# that consumes them)... but users may expect it to work anyway.
tgt.has_field(PythonProvidesField)
or tgt.has_field(PythonSourceField)
or tgt.has_field(ResourceSourceField)
or tgt.get(SourcesField).can_generate(PythonSourceField, union_membership)
or tgt.get(SourcesField).can_generate(ResourceSourceField, union_membership)
# We also check for generating sources so that dependencies on `python_sources(sources=[])`
# is included. Those won't generate any `python_source` targets, but still can be
# dependended upon.
or tgt.has_field(PythonGeneratingSourcesBase)
)
def maybe_get_codegen_request_type(
tgt: Target,
union_membership: UnionMembership) -> GoCodegenBuildRequest | None:
if not tgt.has_field(SourcesField):
return None
generate_request_types = cast(
FrozenOrderedSet[Type[GoCodegenBuildRequest]],
union_membership.get(GoCodegenBuildRequest))
sources_field = tgt[SourcesField]
relevant_requests = [
req for req in generate_request_types
if isinstance(sources_field, req.generate_from)
]
if len(relevant_requests) > 1:
generate_from_sources = relevant_requests[0].generate_from.__name__
raise AmbiguousCodegenImplementationsException(
f"Multiple registered code generators from {GoCodegenBuildRequest.__name__} can "
f"generate from {generate_from_sources}. It is ambiguous which implementation to "
f"use.\n\n"
f"Possible implementations:\n\n"
f"{bullet_list(sorted(generator.__name__ for generator in relevant_requests))}"
)
return relevant_requests[0](tgt) if relevant_requests else None
def is_valid(cls, tgt: Target) -> bool:
return tgt.has_fields(cls.required_fields)
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipFlake8Field).value
def is_ownable_target(tgt: Target, union_membership: UnionMembership) -> bool:
return (tgt.has_field(PythonSources) or tgt.has_field(ResourcesSources)
or tgt.get(Sources).can_generate(PythonSources, union_membership))
def is_applicable(cls, tgt: Target) -> bool:
return tgt.get(UsesMyPycField).value
def is_first_party_package_target(tgt: Target) -> bool:
return tgt.has_field(GoPackageSources)
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipShellcheckField).value
def maybe_get_resolve(t: Target) -> str | None:
if not t.has_field(PythonResolveField):
return None
return t[PythonResolveField].normalized_value(python_setup)
def _is_exported(target: Target) -> bool:
return target.has_field(
PythonProvidesField) and target[PythonProvidesField].value is not None
def belongs_to_language(cls, tgt: Target) -> bool:
return tgt.has_fields(cls.required_fields)
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipHadolintField).value
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipPyUpgradeField).value
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipShunit2TestsField).value
def is_applicable(cls, target: Target) -> bool:
return bool(target.get(RuntimePackageDependenciesField).value)
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipPythonTestsField).value
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipBufFormatField).value
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipMyPyField).value and not tgt.address.is_file_target
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipAutoflakeField).value
def is_third_party_package_target(tgt: Target) -> bool:
return tgt.has_field(GoExternalPackageDependencies)
def filter_target(tgt: Target) -> bool:
return tag in (tgt.get(Tags).value or [])
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(OptOutField).value is True
def is_ownable_target(tgt: Target) -> bool:
return tgt.has_field(PythonSources) or tgt.has_field(ResourcesSources)
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipDocformatterField).value
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipGofmtField).value
def opt_out(cls, tgt: Target) -> bool:
return tgt.get(SkipGoogleJavaFormatField).value