def test_and_filters() -> None:
divisible_by_6 = and_filters(create_filters(["2", "3"], is_divisible_by))
assert divisible_by_6(2) is False
assert divisible_by_6(3) is False
assert divisible_by_6(6) is True
assert divisible_by_6(9) is False
assert divisible_by_6(12) is True
def create(
cls,
filter_subsystem: FilterSubsystem,
registered_target_types: RegisteredTargetTypes,
*,
tags: Iterable[str],
exclude_target_regexps: Iterable[str],
) -> SpecsFilter:
exclude_patterns = tuple(
re.compile(pattern) for pattern in exclude_target_regexps)
def exclude_target_regexps_filter(tgt: Target) -> bool:
return all(
p.search(tgt.address.spec) is None for p in exclude_patterns)
def tags_outer_filter(tag: str) -> TargetFilter:
def tags_inner_filter(tgt: Target) -> bool:
return tag in (tgt.get(Tags).value or [])
return tags_inner_filter
tags_filter = and_filters(create_filters(tags, tags_outer_filter))
return SpecsFilter(
is_specified=bool(filter_subsystem.is_specified() or tags
or exclude_target_regexps),
filter_subsystem_filter=filter_subsystem.all_filters(
registered_target_types),
tags_filter=tags_filter,
exclude_target_regexps_filter=exclude_target_regexps_filter,
)
def filter_targets(
# NB: We must preserve target generators, not replace with their generated targets.
targets: UnexpandedTargets,
filter_subsystem: FilterSubsystem,
console: Console,
registered_target_types: RegisteredTargetTypes,
) -> FilterGoal:
def filter_target_type(target_type: str) -> TargetFilter:
if target_type not in registered_target_types.aliases:
raise UnrecognizedTargetTypeException(target_type,
registered_target_types)
def filt(tgt: Target) -> bool:
if tgt.alias == target_type:
return True
if tgt.deprecated_alias == target_type:
warn_deprecated_target_type(type(tgt))
return True
return False
return filt
def filter_address_regex(address_regex: str) -> TargetFilter:
regex = compile_regex(address_regex)
return lambda tgt: bool(regex.search(tgt.address.spec))
def filter_tag_regex(tag_regex: str) -> TargetFilter:
regex = compile_regex(tag_regex)
return lambda tgt: any(
bool(regex.search(tag)) for tag in tgt.get(Tags).value or ())
def filter_granularity(granularity: TargetGranularity) -> TargetFilter:
return match(
granularity,
{
TargetGranularity.all_targets:
lambda _: True,
TargetGranularity.file_targets:
lambda tgt: tgt.address.is_file_target,
TargetGranularity.build_targets:
lambda tgt: not tgt.address.is_file_target,
},
)
anded_filter: TargetFilter = and_filters([
*(create_filters(filter_subsystem.options.target_type,
filter_target_type)),
*(create_filters(filter_subsystem.options.address_regex,
filter_address_regex)),
*(create_filters(filter_subsystem.options.tag_regex,
filter_tag_regex)),
filter_granularity(filter_subsystem.options.granularity),
])
addresses = sorted(target.address for target in targets
if anded_filter(target))
with filter_subsystem.line_oriented(console) as print_stdout:
for address in addresses:
print_stdout(address.spec)
return FilterGoal(exit_code=0)
def filter_targets(
targets: Targets,
options: FilterOptions,
console: Console,
registered_target_types: RegisteredTargetTypes,
) -> FilterGoal:
def filter_target_type(target_type: str) -> TargetFilter:
if target_type not in registered_target_types.aliases:
raise UnrecognizedTargetTypeException(target_type,
registered_target_types)
return lambda tgt: tgt.alias == target_type
def filter_address_regex(address_regex: str) -> TargetFilter:
regex = compile_regex(address_regex)
return lambda tgt: bool(regex.search(tgt.address.spec))
def filter_tag_regex(tag_regex: str) -> TargetFilter:
regex = compile_regex(tag_regex)
return lambda tgt: any(
bool(regex.search(tag)) for tag in tgt.get(Tags).value or ())
anded_filter: TargetFilter = and_filters([
*(create_filters(options.values.target_type, filter_target_type)),
*(create_filters(options.values.address_regex, filter_address_regex)),
*(create_filters(options.values.tag_regex, filter_tag_regex)),
])
addresses = sorted(target.address for target in targets
if anded_filter(target))
with options.line_oriented(console) as print_stdout:
for address in addresses:
print_stdout(address)
return FilterGoal(exit_code=0)
def _tag_filter(self):
def filter_for_tag(tag: str) -> Callable[[Target], bool]:
def filter_target(tgt: Target) -> bool:
return tag in (tgt.get(Tags).value or [])
return filter_target
return and_filters(create_filters(self.tags, filter_for_tag))
def all_filters(self, registered_target_types: RegisteredTargetTypes) -> TargetFilter:
return and_filters(
[
*self.target_type_filters(registered_target_types),
*self.address_regex_filters(),
*self.tag_regex_filters(),
self.granularity_filter(),
]
)
def _tag_filter(self):
def filter_for_tag(tag: str) -> Callable[[TargetAdaptor], bool]:
def filter_target(tgt: TargetAdaptor) -> bool:
# `tags` can sometimes be explicitly set to `None`. We convert that to an empty list
# with `or`.
tags = tgt.kwargs.get("tags", []) or []
return tag in [str(t_tag) for t_tag in tags]
return filter_target
return and_filters(create_filters(self.tags, filter_for_tag))
def _target_tag_matches(self):
def filter_for_tag(tag):
def filter_target(tgt):
# `tags` can sometimes be explicitly set to `None`. We convert that to an empty list
# with `or`.
tags = tgt.kwargs().get("tags", []) or []
return tag in [str(t_tag) for t_tag in tags]
return filter_target
return and_filters(create_filters(self.tags, filter_for_tag))
def filter_targets(
targets: UnexpandedTargets,
filter_subsystem: FilterSubsystem,
console: Console,
registered_target_types: RegisteredTargetTypes,
) -> FilterGoal:
if not filter_subsystem.options.is_default("target"):
raise ValueError(TARGET_REMOVAL_MSG)
if not filter_subsystem.options.is_default("ancestor"):
raise ValueError(ANCESTOR_REMOVAL_MSG)
def filter_target_type(target_type: str) -> TargetFilter:
if target_type not in registered_target_types.aliases:
raise UnrecognizedTargetTypeException(target_type,
registered_target_types)
return lambda tgt: tgt.alias == target_type
def filter_address_regex(address_regex: str) -> TargetFilter:
regex = compile_regex(address_regex)
return lambda tgt: bool(regex.search(tgt.address.spec))
def filter_tag_regex(tag_regex: str) -> TargetFilter:
regex = compile_regex(tag_regex)
return lambda tgt: any(
bool(regex.search(tag)) for tag in tgt.get(Tags).value or ())
resolve_option = partial(
resolve_conflicting_options,
old_scope="filter",
new_scope="filter",
old_container=filter_subsystem.options,
new_container=filter_subsystem.options,
)
target_type = resolve_option(old_option="type", new_option="target_type")
address_regex = resolve_option(old_option="regex",
new_option="address_regex")
anded_filter: TargetFilter = and_filters([
*(create_filters(target_type, filter_target_type)),
*(create_filters(address_regex, filter_address_regex)),
*(create_filters(filter_subsystem.options.tag_regex,
filter_tag_regex)),
])
addresses = sorted(target.address for target in targets
if anded_filter(target))
with filter_subsystem.line_oriented(console) as print_stdout:
for address in addresses:
print_stdout(address.spec)
return FilterGoal(exit_code=0)