def compute_value( cls, raw_value: Optional[Iterable[str]], *, address: Address ) -> Tuple[Requirement, ...]: value = super().compute_value(raw_value, address=address) invalid_type_error = InvalidFieldTypeException( address, cls.alias, value, expected_type="an iterable of pip-style requirement strings (e.g. a list)", ) if isinstance(value, str) or not isinstance(value, collections.abc.Iterable): raise invalid_type_error result = [] for v in value: # We allow passing a pre-parsed `Requirement`. This is intended for macros which might # have already parsed so that we can avoid parsing multiple times. if isinstance(v, Requirement): result.append(v) elif isinstance(v, str): try: parsed = Requirement.parse(v) except Exception as e: raise InvalidFieldException( format_invalid_requirement_string_error( v, e, description_of_origin=( f"the '{cls.alias}' field for the target {address}" ), ) ) result.append(parsed) else: raise invalid_type_error return tuple(result)
def compute_value( cls, raw_value: Optional[Union[Iterable[str], Dict[str, Iterable[str]]]], *, address: Address, ) -> Optional[Union[Tuple[str, ...], FrozenDict[str, Tuple[str, ...]]]]: value_or_default = super().compute_value(raw_value, address=address) invalid_field_type_exception = InvalidFieldTypeException( address, cls.alias, value_or_default, expected_type= ("either an iterable of strings or a dictionary of platforms to iterable of " "strings"), ) if isinstance(value_or_default, dict): try: return FrozenDict({ platform: tuple(sorted(ensure_str_list(lib_names))) for platform, lib_names in value_or_default.items() }) except ValueError: raise invalid_field_type_exception try: ensure_str_list(value_or_default) except ValueError: raise invalid_field_type_exception return tuple(sorted(value_or_default))
def compute_value(cls, raw_value: Optional[Dict[str, Any]], *, address: Address) -> Optional[Dict[str, Any]]: value_or_default = super().compute_value(raw_value, address=address) if value_or_default is not None and not isinstance( value_or_default, dict): raise InvalidFieldTypeException(address, cls.alias, value_or_default, expected_type="a dictionary") return value_or_default
def compute_value(cls, raw_value: Optional[str], address: Address) -> Optional[ConsoleScript]: value = super().compute_value(raw_value, address) if value is None: return None if not isinstance(value, str): raise InvalidFieldTypeException(address, cls.alias, value, expected_type="a string") return ConsoleScript(value)
def compute_value(cls, raw_value: Optional[str], address: Address) -> EntryPoint: value = super().compute_value(raw_value, address) if not isinstance(value, str): raise InvalidFieldTypeException(address, cls.alias, value, expected_type="a string") try: return EntryPoint.parse(value, provenance=f"for {address}") except ValueError as e: raise InvalidFieldException(str(e))
def compute_value( # type: ignore[override] cls, raw_value: Optional[Union[str, HTTPSource]], address: Address) -> Optional[Union[str, HTTPSource]]: if raw_value is None or isinstance(raw_value, str): return super().compute_value(raw_value, address) elif not isinstance(raw_value, HTTPSource): raise InvalidFieldTypeException( address, cls.alias, raw_value, expected_type="a string or an `http_source` object", ) return raw_value
def compute_value(cls, raw_value: Optional[Iterable[str]], *, address: Address) -> Tuple[Requirement, ...]: value = super().compute_value(raw_value, address=address) invalid_type_error = InvalidFieldTypeException( address, cls.alias, value, expected_type= "an iterable of pip-style requirement strings (e.g. a list)", ) if isinstance(value, (str, PythonRequirement)) or not isinstance( value, collections.abc.Iterable): raise invalid_type_error result = [] for v in value: # We allow passing a pre-parsed `Requirement`. This is intended for macros which might # have already parsed so that we can avoid parsing multiple times. if isinstance(v, Requirement): result.append(v) elif isinstance(v, str): try: parsed = Requirement.parse(v) except Exception as e: raise InvalidFieldException( format_invalid_requirement_string_error( v, e, description_of_origin= (f"the '{cls.alias}' field for the target {address}" ), )) result.append(parsed) elif isinstance(v, PythonRequirement): extra_suggestions = "" if v.repository: extra_suggestions += ( f"\n\nInstead of setting 'repository={v.repository}`, add this to the " "option `repos` in the `[python-repos]` options scope." ) warn_or_error( removal_version="2.1.0.dev0", deprecated_entity_description="Using `pants_requirement`", hint= (f"In the '{cls.alias}' field for {address}, use '{str(v.requirement)}' " f"instead of 'pants_requirement('{str(v.requirement)}').{extra_suggestions}" ), ) result.append(v.requirement) else: raise invalid_type_error return tuple(result)
def compute_value( cls, raw_value: Optional[Union[str, Dict[str, str]]], *, address: Address ) -> Optional[Union[str, FrozenDict[str, str]]]: value_or_default = super().compute_value(raw_value, address=address) if value_or_default is None: return None if isinstance(value_or_default, str): return value_or_default if isinstance(value_or_default, dict): return FrozenDict(value_or_default) raise InvalidFieldTypeException( address, cls.alias, value_or_default, expected_type="either a string or a dictionary of executable name to local file name.", )
def compute_value(cls, raw_value: Optional[str], address: Address) -> Optional[EntryPoint]: value = super().compute_value(raw_value, address) if value is None: return None if not isinstance(value, str): raise InvalidFieldTypeException(address, cls.alias, value, expected_type="a string") if value in {"<none>", "<None>"}: warn_or_error( "2.9.0.dev0", "using `<none>` for the `entry_point` field", ("Rather than setting `entry_point='<none>' for the pex_binary target " f"{address}, simply leave off the field."), ) return None try: return EntryPoint.parse(value, provenance=f"for {address}") except ValueError as e: raise InvalidFieldException(str(e))