def test_find_thrift_python_requirement(rule_runner: RuleRunner) -> None: rule_runner.write_files({"codegen/dir/f.thrift": "", "codegen/dir/BUILD": "thrift_sources()"}) rule_runner.set_options( ["--python-resolves={'python-default': '', 'another': ''}", "--python-enable-resolves"] ) thrift_tgt = rule_runner.get_target(Address("codegen/dir", relative_file_path="f.thrift")) request = InjectApacheThriftPythonDependencies(thrift_tgt[Dependencies]) # Start with no relevant requirements. with engine_error(MissingPythonCodegenRuntimeLibrary): rule_runner.request(InjectedDependencies, [request]) # If exactly one, match it. rule_runner.write_files({"reqs1/BUILD": "python_requirement(requirements=['thrift'])"}) assert rule_runner.request(InjectedDependencies, [request]) == InjectedDependencies( [Address("reqs1")] ) # Multiple is fine if from other resolve. rule_runner.write_files( {"another_resolve/BUILD": "python_requirement(requirements=['thrift'], resolve='another')"} ) assert rule_runner.request(InjectedDependencies, [request]) == InjectedDependencies( [Address("reqs1")] ) # If multiple from the same resolve, error. rule_runner.write_files({"reqs2/BUILD": "python_requirement(requirements=['thrift'])"}) with engine_error( AmbiguousPythonCodegenRuntimeLibrary, contains="['reqs1:reqs1', 'reqs2:reqs2']" ): rule_runner.request(InjectedDependencies, [request])
async def inject_lambda_handler_dependency( request: InjectPythonLambdaHandlerDependency, python_infer_subsystem: PythonInferSubsystem) -> InjectedDependencies: if not python_infer_subsystem.entry_points: return InjectedDependencies() original_tgt = await Get(WrappedTarget, Address, request.dependencies_field.address) explicitly_provided_deps, handler = await MultiGet( Get(ExplicitlyProvidedDependencies, DependenciesRequest(original_tgt.target[Dependencies])), Get( ResolvedPythonAwsHandler, ResolvePythonAwsHandlerRequest( original_tgt.target[PythonAwsLambdaHandlerField]), ), ) module, _, _func = handler.val.partition(":") owners = await Get(PythonModuleOwners, PythonModule(module)) address = original_tgt.target.address explicitly_provided_deps.maybe_warn_of_ambiguous_dependency_inference( owners.ambiguous, address, import_reference="module", context= (f"The python_awslambda target {address} has the field " f"`handler={repr(original_tgt.target[PythonAwsLambdaHandlerField].value)}`, which maps " f"to the Python module `{module}`"), ) maybe_disambiguated = explicitly_provided_deps.disambiguated_via_ignores( owners.ambiguous) unambiguous_owners = owners.unambiguous or ( (maybe_disambiguated, ) if maybe_disambiguated else ()) return InjectedDependencies(unambiguous_owners)
async def inject_pex_binary_entry_point_dependency( request: InjectPexBinaryEntryPointDependency, python_infer_subsystem: PythonInferSubsystem) -> InjectedDependencies: if not python_infer_subsystem.entry_points: return InjectedDependencies() original_tgt = await Get(WrappedTarget, Address, request.dependencies_field.address) explicitly_provided_deps, entry_point = await MultiGet( Get(ExplicitlyProvidedDependencies, DependenciesRequest(original_tgt.target[Dependencies])), Get( ResolvedPexEntryPoint, ResolvePexEntryPointRequest( original_tgt.target[PexEntryPointField]), ), ) if entry_point.val is None: return InjectedDependencies() owners = await Get(PythonModuleOwners, PythonModule(entry_point.val.module)) address = original_tgt.target.address explicitly_provided_deps.maybe_warn_of_ambiguous_dependency_inference( owners.ambiguous, address, import_reference="module", context= (f"The pex_binary target {address} has the field " f"`entry_point={repr(original_tgt.target[PexEntryPointField].value.spec)}`, which " f"maps to the Python module `{entry_point.val.module}`"), ) maybe_disambiguated = explicitly_provided_deps.disambiguated_via_ignores( owners.ambiguous) unambiguous_owners = owners.unambiguous or ( (maybe_disambiguated, ) if maybe_disambiguated else ()) return InjectedDependencies(unambiguous_owners)
async def find_apache_thrift_python_requirement( request: InjectApacheThriftPythonDependencies, thrift_python: ThriftPythonSubsystem, python_setup: PythonSetup, # TODO(#12946): Make this a lazy Get once possible. module_mapping: ThirdPartyPythonModuleMapping, ) -> InjectedDependencies: if not thrift_python.infer_runtime_dependency: return InjectedDependencies() wrapped_tgt = await Get( WrappedTarget, WrappedTargetRequest( request.dependencies_field.address, description_of_origin="<infallible>" ), ) resolve = wrapped_tgt.target.get(PythonResolveField).normalized_value(python_setup) addr = find_python_runtime_library_or_raise_error( module_mapping, request.dependencies_field.address, "thrift", resolve=resolve, resolves_enabled=python_setup.enable_resolves, recommended_requirement_name="thrift", recommended_requirement_url="https://pypi.org/project/thrift/", disable_inference_option=f"[{thrift_python.options_scope}].infer_runtime_dependency", ) return InjectedDependencies([addr])
async def inject_python_distribution_dependencies( request: InjectPythonDistributionDependencies, python_infer_subsystem: PythonInferSubsystem) -> InjectedDependencies: """Inject dependencies that we can infer from entry points in the distribution.""" if not python_infer_subsystem.entry_points: return InjectedDependencies() original_tgt = await Get(WrappedTarget, Address, request.dependencies_field.address) explicitly_provided_deps, distribution_entry_points, provides_entry_points = await MultiGet( Get(ExplicitlyProvidedDependencies, DependenciesRequest(original_tgt.target[Dependencies])), Get( ResolvedPythonDistributionEntryPoints, ResolvePythonDistributionEntryPointsRequest( entry_points_field=original_tgt. target[PythonDistributionEntryPointsField]), ), Get( ResolvedPythonDistributionEntryPoints, ResolvePythonDistributionEntryPointsRequest( provides_field=original_tgt.target[PythonProvidesField]), ), ) address = original_tgt.target.address all_module_entry_points = [ (category, name, entry_point) for category, entry_points in chain( distribution_entry_points.explicit_modules.items(), provides_entry_points.explicit_modules.items(), ) for name, entry_point in entry_points.items() ] all_module_owners = iter(await MultiGet( Get(PythonModuleOwners, PythonModuleOwnersRequest(entry_point.module, resolve=None)) for _, _, entry_point in all_module_entry_points)) module_owners: OrderedSet[Address] = OrderedSet() for (category, name, entry_point), owners in zip(all_module_entry_points, all_module_owners): field_str = repr({category: {name: entry_point.spec}}) explicitly_provided_deps.maybe_warn_of_ambiguous_dependency_inference( owners.ambiguous, address, import_reference="module", context=( f"The python_distribution target {address} has the field " f"`entry_points={field_str}`, which maps to the Python module" f"`{entry_point.module}`"), ) maybe_disambiguated = explicitly_provided_deps.disambiguated( owners.ambiguous) unambiguous_owners = owners.unambiguous or ( (maybe_disambiguated, ) if maybe_disambiguated else ()) module_owners.update(unambiguous_owners) return InjectedDependencies( Addresses(module_owners) + distribution_entry_points.pex_binary_addresses + provides_entry_points.pex_binary_addresses)
async def inject_go_package_dependencies( request: InjectGoPackageDependenciesRequest, ) -> InjectedDependencies: owning_go_module_result = await Get( ResolvedOwningGoModule, FindNearestGoModuleRequest( request.dependencies_field.address.spec_path), ) if owning_go_module_result.module_address: return InjectedDependencies([owning_go_module_result.module_address]) else: return InjectedDependencies()
async def inject_pex_binary_entry_point_dependency( request: InjectPexBinaryEntryPointDependency, python_infer_subsystem: PythonInferSubsystem, python_setup: PythonSetup, ) -> InjectedDependencies: if not python_infer_subsystem.entry_points: return InjectedDependencies() original_tgt = await Get( WrappedTarget, WrappedTargetRequest( request.dependencies_field.address, description_of_origin="<infallible>" ), ) entry_point_field = original_tgt.target.get(PexEntryPointField) if entry_point_field.value is None: return InjectedDependencies() explicitly_provided_deps, entry_point = await MultiGet( Get(ExplicitlyProvidedDependencies, DependenciesRequest(original_tgt.target[Dependencies])), Get(ResolvedPexEntryPoint, ResolvePexEntryPointRequest(entry_point_field)), ) if entry_point.val is None: return InjectedDependencies() owners = await Get( PythonModuleOwners, PythonModuleOwnersRequest( entry_point.val.module, resolve=original_tgt.target[PythonResolveField].normalized_value(python_setup), ), ) address = original_tgt.target.address explicitly_provided_deps.maybe_warn_of_ambiguous_dependency_inference( owners.ambiguous, address, # If the entry point was specified as a file, like `app.py`, we know the module must # live in the pex_binary's directory or subdirectory, so the owners must be ancestors. owners_must_be_ancestors=entry_point.file_name_used, import_reference="module", context=softwrap( f""" The pex_binary target {address} has the field `entry_point={repr(entry_point_field.value.spec)}`, which maps to the Python module `{entry_point.val.module}` """ ), ) maybe_disambiguated = explicitly_provided_deps.disambiguated( owners.ambiguous, owners_must_be_ancestors=entry_point.file_name_used ) unambiguous_owners = owners.unambiguous or ( (maybe_disambiguated,) if maybe_disambiguated else () ) return InjectedDependencies(unambiguous_owners)
async def inject_lambda_handler_dependency( request: InjectPythonLambdaHandlerDependency, python_infer_subsystem: PythonInferSubsystem ) -> InjectedDependencies: if not python_infer_subsystem.entry_points: return InjectedDependencies() original_tgt = await Get(WrappedTarget, Address, request.dependencies_field.address) handler = await Get( ResolvedPythonAwsHandler, ResolvePythonAwsHandlerRequest(original_tgt.target[PythonAwsLambdaHandlerField]), ) module, _, _func = handler.val.partition(":") owners = await Get(PythonModuleOwners, PythonModule(module)) return InjectedDependencies(owners)
async def inject_lambda_handler_dependency( request: InjectPythonLambdaHandlerDependency, python_infer_subsystem: PythonInferSubsystem, python_setup: PythonSetup, ) -> InjectedDependencies: if not python_infer_subsystem.entry_points: return InjectedDependencies() original_tgt = await Get( WrappedTarget, WrappedTargetRequest( request.dependencies_field.address, description_of_origin="<infallible>" ), ) explicitly_provided_deps, handler = await MultiGet( Get(ExplicitlyProvidedDependencies, DependenciesRequest(original_tgt.target[Dependencies])), Get( ResolvedPythonAwsHandler, ResolvePythonAwsHandlerRequest(original_tgt.target[PythonAwsLambdaHandlerField]), ), ) module, _, _func = handler.val.partition(":") owners = await Get( PythonModuleOwners, PythonModuleOwnersRequest( module, resolve=original_tgt.target[PythonResolveField].normalized_value(python_setup) ), ) address = original_tgt.target.address explicitly_provided_deps.maybe_warn_of_ambiguous_dependency_inference( owners.ambiguous, address, # If the handler was specified as a file, like `app.py`, we know the module must # live in the python_awslambda's directory or subdirectory, so the owners must be ancestors. owners_must_be_ancestors=handler.file_name_used, import_reference="module", context=softwrap( f""" The python_awslambda target {address} has the field `handler={repr(original_tgt.target[PythonAwsLambdaHandlerField].value)}`, which maps to the Python module `{module}`" """ ), ) maybe_disambiguated = explicitly_provided_deps.disambiguated( owners.ambiguous, owners_must_be_ancestors=handler.file_name_used ) unambiguous_owners = owners.unambiguous or ( (maybe_disambiguated,) if maybe_disambiguated else () ) return InjectedDependencies(unambiguous_owners)
async def inject_pex_binary_entry_point_dependency( request: InjectPexBinaryEntryPointDependency, python_infer_subsystem: PythonInferSubsystem ) -> InjectedDependencies: if not python_infer_subsystem.entry_points: return InjectedDependencies() original_tgt = await Get(WrappedTarget, Address, request.dependencies_field.address) entry_point = await Get( ResolvedPexEntryPoint, ResolvePexEntryPointRequest(original_tgt.target[PexEntryPointField]), ) if entry_point.val is None: return InjectedDependencies() module, _, _func = entry_point.val.partition(":") owners = await Get(PythonModuleOwners, PythonModule(module)) return InjectedDependencies(owners)
async def inject_scala_library_dependency( request: InjectScalaLibraryDependencyRequest, jvm: JvmSubsystem, ) -> InjectedDependencies: wrapped_target = await Get(WrappedTarget, Address, request.dependencies_field.address) target = wrapped_target.target if not target.has_field(JvmResolveField): return InjectedDependencies() resolve = target[JvmResolveField].normalized_value(jvm) scala_library_target_info = await Get( ScalaRuntimeForResolve, ScalaRuntimeForResolveRequest(resolve) ) return InjectedDependencies((scala_library_target_info.address,))
async def inject_dependencies( request: InjectPythonProtobufDependencies, python_protobuf: PythonProtobufSubsystem, python_setup: PythonSetup, # TODO(#12946): Make this a lazy Get once possible. module_mapping: ThirdPartyPythonModuleMapping, ) -> InjectedDependencies: if not python_protobuf.infer_runtime_dependency: return InjectedDependencies() wrapped_tgt = await Get( WrappedTarget, WrappedTargetRequest(request.dependencies_field.address, description_of_origin="<infallible>"), ) tgt = wrapped_tgt.target resolve = tgt.get(PythonResolveField).normalized_value(python_setup) result = [ find_python_runtime_library_or_raise_error( module_mapping, request.dependencies_field.address, "google.protobuf", resolve=resolve, resolves_enabled=python_setup.enable_resolves, recommended_requirement_name="protobuf", recommended_requirement_url="https://pypi.org/project/protobuf/", disable_inference_option= f"[{python_protobuf.options_scope}].infer_runtime_dependency", ) ] if tgt.get(ProtobufGrpcToggleField).value: result.append( find_python_runtime_library_or_raise_error( module_mapping, request.dependencies_field.address, # Note that the library is called `grpcio`, but the module is `grpc`. "grpc", resolve=resolve, resolves_enabled=python_setup.enable_resolves, recommended_requirement_name="grpcio", recommended_requirement_url="https://pypi.org/project/grpcio/", disable_inference_option= f"[{python_protobuf.options_scope}].infer_runtime_dependency", )) return InjectedDependencies(result)
def assert_injected(address: Address, expected: list[Address]) -> None: tgt = rule_runner.get_target(address) injected = rule_runner.request( InjectedDependencies, [InjectPythonDistributionDependencies(tgt[PythonDistributionDependenciesField])], ) assert injected == InjectedDependencies(expected)
def assert_injected(addr: Address) -> None: tgt = rule_runner.get_target(addr) injected = rule_runner.request( InjectedDependencies, [InjectPythonProtobufDependencies(tgt[ProtobufDependenciesField])]) assert injected == InjectedDependencies( [Address("protos", target_name="injected_dep")])
def assert_injected(address: Address, *, expected: Address | None) -> None: tgt = rule_runner.get_target(address) injected = rule_runner.request( InjectedDependencies, [InjectPexBinaryEntryPointDependency(tgt[PexBinaryDependenciesField])], ) assert injected == InjectedDependencies([expected] if expected else [])
async def inject_dependencies(_: InjectProtobufDependencies, protoc: Protoc) -> InjectedDependencies: addresses = await Get( Addresses, UnparsedAddressInputs((v for v in protoc.runtime_targets), owning_address=None)) return InjectedDependencies(addresses)
async def inject_docker_dependencies(request: InjectDockerDependencies) -> InjectedDependencies: """Inspects COPY instructions in the Dockerfile for references to known packagable targets.""" dockerfile_info = await Get( DockerfileInfo, DockerfileInfoRequest(request.dependencies_field.address) ) # Parse all putative target addresses. putative_addresses = await Get( Addresses, UnparsedAddressInputs( dockerfile_info.putative_target_addresses, owning_address=dockerfile_info.address, ), ) # Get the target for those addresses that are known. directories = {address.spec_path for address in putative_addresses} all_addresses = await Get(Addresses, AddressSpecs(map(MaybeEmptySiblingAddresses, directories))) targets = await Get( Targets, Addresses((address for address in putative_addresses if address in all_addresses)) ) # Only keep those targets that we can "package". package = await Get(FieldSetsPerTarget, FieldSetsPerTargetRequest(PackageFieldSet, targets)) referenced_targets = ( field_sets[0].address for field_sets in package.collection if len(field_sets) > 0 ) return InjectedDependencies(Addresses(referenced_targets))
def test_inject_dependencies() -> None: rule_runner = RuleRunner( rules=[ *target_type_rules(), QueryRule(InjectedDependencies, (InjectProtobufDependencies, )), ], target_types=[ProtobufLibrary, Files], ) rule_runner.set_options([ "--backend-packages=pants.backend.codegen.protobuf.python", "--protoc-runtime-targets=protos:injected_dep", ]) # Note that injected deps can be any target type for `--protobuf-runtime-targets`. rule_runner.add_to_build_file( "protos", dedent("""\ protobuf_library() files(name="injected_dep", sources=[]) """), ) tgt = rule_runner.get_target(Address("protos")) injected = rule_runner.request( InjectedDependencies, [InjectProtobufDependencies(tgt[ProtobufDependencies])]) assert injected == InjectedDependencies( [Address("protos", target_name="injected_dep")])
def test_inject_docker_dependencies(rule_runner: RuleRunner) -> None: rule_runner.add_to_build_file( "project/image/test", dedent("""\ docker_image(name="image") """), ) rule_runner.create_file( "project/image/test/Dockerfile", dedent("""\ FROM baseimage ENTRYPOINT ["./entrypoint"] COPY project.hello.main/main_binary.pex /entrypoint """), ) rule_runner.add_to_build_file( "project/hello/main", dedent("""\ pex_binary(name="main_binary") """), ) tgt = rule_runner.get_target( Address("project/image/test", target_name="image")) injected = rule_runner.request( InjectedDependencies, [InjectDockerDependencies(tgt[DockerDependencies])], ) assert injected == InjectedDependencies( [Address("project/hello/main", target_name="main_binary")])
def test_inject_docker_dependencies(rule_runner: RuleRunner) -> None: rule_runner.write_files({ "project/image/test/BUILD": dedent("""\ docker_image(name="base") docker_image(name="image") """), "project/image/test/Dockerfile": dedent("""\ ARG BASE_IMAGE=:base FROM $BASE_IMAGE ENTRYPOINT ["./entrypoint"] COPY project.hello.main/main_binary.pex /entrypoint """), "project/hello/main/BUILD": dedent("""\ pex_binary(name="main_binary") """), }) tgt = rule_runner.get_target( Address("project/image/test", target_name="image")) injected = rule_runner.request( InjectedDependencies, [InjectDockerDependencies(tgt[DockerImageDependenciesField])], ) assert injected == InjectedDependencies([ Address("project/hello/main", target_name="main_binary"), Address("project/image/test", target_name="base"), ])
async def inject_go_external_package_dependencies( request: InjectGoExternalPackageDependenciesRequest, std_lib_imports: GoStdLibImports, package_mapping: GoImportPathToPackageMapping, ) -> InjectedDependencies: this_go_package = await Get( ResolvedGoPackage, ResolveExternalGoPackageRequest(request.dependencies_field.address)) # Loop through all of the imports of this package and add dependencies on other packages and # external modules. inferred_dependencies = [] for import_path in this_go_package.imports + this_go_package.test_imports: if import_path in std_lib_imports: continue # Infer third-party dependencies on _go_external_package targets. candidate_third_party_packages = package_mapping.mapping.get( import_path, ()) if len(candidate_third_party_packages) > 1: # TODO: Use ExplicitlyProvidedDependencies.maybe_warn_of_ambiguous_dependency_inference standard # way of doing disambiguation. logger.warning( f"Ambiguous mapping for import path {import_path} on packages at addresses: {candidate_third_party_packages}" ) elif len(candidate_third_party_packages) == 1: inferred_dependencies.append(candidate_third_party_packages[0]) else: logger.debug( f"Unable to infer dependency for import path '{import_path}' " f"in go_external_package at address '{this_go_package.address}'." ) return InjectedDependencies(inferred_dependencies)
def test_python_distribution_dependency_injection() -> None: rule_runner = RuleRunner( rules=[ *target_type_rules(), QueryRule( InjectedDependencies, (InjectPythonDistributionDependencies, ), ), ], target_types=[PythonDistribution, PexBinary], objects={"setup_py": PythonArtifact}, ) rule_runner.add_to_build_file( "project", dedent("""\ pex_binary(name="my_binary") python_distribution( name="dist", provides=setup_py( name='my-dist' ).with_binaries({"my_cmd": ":my_binary"}) ) """), ) tgt = rule_runner.get_target(Address("project", target_name="dist")) injected = rule_runner.request( InjectedDependencies, [ InjectPythonDistributionDependencies( tgt[PythonDistributionDependencies]) ], ) assert injected == InjectedDependencies( [Address("project", target_name="my_binary")])
def assert_injected(address: Address, *, expected: Optional[Address]) -> None: tgt = rule_runner.get_target(address) injected = rule_runner.request( InjectedDependencies, [InjectPythonLambdaHandlerDependency(tgt[PythonAwsLambdaDependencies])], ) assert injected == InjectedDependencies([expected] if expected else [])
async def inject_apache_thrift_java_dependencies( request: InjectApacheThriftJavaDependencies, jvm: JvmSubsystem) -> InjectedDependencies: wrapped_target = await Get( WrappedTarget, WrappedTargetRequest(request.dependencies_field.address, description_of_origin="<infallible>"), ) target = wrapped_target.target if not target.has_field(JvmResolveField): return InjectedDependencies() resolve = target[JvmResolveField].normalized_value(jvm) dependencies_info = await Get( ApacheThriftJavaRuntimeForResolve, ApacheThriftJavaRuntimeForResolveRequest(resolve)) return InjectedDependencies(dependencies_info.addresses)
async def inject_dependencies( request: InjectPythonDistributionDependencies, ) -> InjectedDependencies: """Inject any `.with_binaries()` values, as it would be redundant to have to include in the `dependencies` field.""" original_tgt = await Get(WrappedTarget, Address, request.dependencies_field.address) with_binaries = original_tgt.target[PythonProvidesField].value.binaries if not with_binaries: return InjectedDependencies() # Note that we don't validate that these are all `pex_binary` targets; we don't care about # that here. `setup_py.py` will do that validation. addresses = await Get( Addresses, UnparsedAddressInputs( with_binaries.values(), owning_address=request.dependencies_field.address), ) return InjectedDependencies(addresses)
async def inject_scalapb_runtime_dependency( request: InjectScalaPBRuntimeDependencyRequest, jvm: JvmSubsystem, ) -> InjectedDependencies: wrapped_target = await Get( WrappedTarget, WrappedTargetRequest(request.dependencies_field.address, description_of_origin="<infallible>"), ) target = wrapped_target.target if not target.has_field(JvmResolveField): return InjectedDependencies() resolve = target[JvmResolveField].normalized_value(jvm) scalapb_runtime_target_info = await Get( ScalaPBRuntimeForResolve, ScalaPBRuntimeForResolveRequest(resolve)) return InjectedDependencies(scalapb_runtime_target_info.addresses)
async def inject_scala_plugin_dependencies( request: InjectScalaPluginDependenciesRequest, ) -> InjectedDependencies: """Adds dependencies on plugins for scala source files, so that they get included in the target's resolve.""" wrapped_target = await Get(WrappedTarget, Address, request.dependencies_field.address) target = wrapped_target.target if not target.has_field(JvmResolveField): return InjectedDependencies() scala_plugins = await Get( ScalaPluginTargetsForTarget, ScalaPluginsForTargetWithoutResolveRequest(target) ) plugin_addresses = [target.address for target in scala_plugins.artifacts] return InjectedDependencies(plugin_addresses)
async def inject_go_binary_main_dependency( request: InjectGoBinaryMainDependencyRequest, ) -> InjectedDependencies: wrapped_tgt = await Get(WrappedTarget, Address, request.dependencies_field.address) main_pkg = await Get( GoBinaryMainPackage, GoBinaryMainPackageRequest( wrapped_tgt.target[GoBinaryMainPackageField]), ) return InjectedDependencies([main_pkg.address])
async def inject_kotlin_junit_dependency( request: InjectKotlinJunitTestDependencyRequest, jvm: JvmSubsystem, ) -> InjectedDependencies: wrapped_target = await Get( WrappedTarget, WrappedTargetRequest(request.dependencies_field.address, description_of_origin="<infallible>"), ) target = wrapped_target.target if not target.has_field(JvmResolveField): return InjectedDependencies() resolve = target[JvmResolveField].normalized_value(jvm) kotlin_junit_libraries = await Get( KotlinJunitLibrariesForResolve, KotlinJunitLibrariesForResolveRequest(resolve)) return InjectedDependencies(kotlin_junit_libraries.addresses)
async def inject_pex_binary_entry_point_dependency( request: InjectPexBinaryEntryPointDependency, python_infer_subsystem: PythonInferSubsystem) -> InjectedDependencies: if not python_infer_subsystem.entry_points: return InjectedDependencies() original_tgt = await Get(WrappedTarget, Address, request.dependencies_field.address) entry_point = await Get( ResolvedPexEntryPoint, ResolvePexEntryPointRequest( original_tgt.target[PexEntryPointField], original_tgt.target[DeprecatedPexBinarySources]), ) if entry_point.val is None: return InjectedDependencies() module, _, _func = entry_point.val.partition(":") owners = await Get(PythonModuleOwners, PythonModule(module)) # TODO: remove the check for == self once the `sources` field is removed. return InjectedDependencies(owner for owner in owners if owner != request.dependencies_field.address)