def get_report(self) -> str: """Get verbose report. :return: Report why the part is dirty. :rtype: str """ messages = [] # type: List[str] if self.dirty_properties: humanized_properties = formatting_utils.humanize_list( self.dirty_properties, "and") pluralized_connection = formatting_utils.pluralize( self.dirty_properties, "property appears", "properties appear") messages.append("The {} part {} to have changed.\n".format( humanized_properties, pluralized_connection)) if self.dirty_project_options: humanized_options = formatting_utils.humanize_list( self.dirty_project_options, "and") pluralized_connection = formatting_utils.pluralize( self.dirty_project_options, "option appears", "options appear") messages.append("The {} project {} to have changed.\n".format( humanized_options, pluralized_connection)) if self.changed_dependencies: dependencies = [d.part_name for d in self.changed_dependencies] messages.append("{} changed: {}\n".format( formatting_utils.pluralize(dependencies, "A dependency has", "Some dependencies have"), formatting_utils.humanize_list(dependencies, "and"), )) return "".join(messages)
def __init__(self, *, base: str, version: str, valid_versions: Sequence[str]) -> None: super().__init__( base=base, version=version, valid_versions=formatting_utils.humanize_list(valid_versions, conjunction="or"), )
def _determine_cause(error): messages = [] # error.validator_value may contain a custom validation error message. # If so, use it instead of the garbage message jsonschema gives us. with contextlib.suppress(TypeError, KeyError): messages.append( error.validator_value["validation-failure"].format(error)) # The schema itself may have a custom validation error message. If so, # use it as well. with contextlib.suppress(AttributeError, TypeError, KeyError): key = error if (error.schema.get("type") == "object" and error.validator == "additionalProperties"): key = list(error.instance.keys())[0] messages.append(error.schema["validation-failure"].format(key)) # anyOf failures might have usable context... try to improve them a bit if error.validator == "anyOf": contextual_messages: Dict[str, str] = collections.OrderedDict() for contextual_error in error.context: key = contextual_error.schema_path.popleft() if key not in contextual_messages: contextual_messages[key] = [] message = contextual_error.message if message: # Sure it starts lower-case (not all messages do) contextual_messages[key].append(message[0].lower() + message[1:]) oneOf_messages: List[str] = [] for key, value in contextual_messages.items(): oneOf_messages.append( formatting_utils.humanize_list(value, "and", "{}")) messages.append( formatting_utils.humanize_list(oneOf_messages, "or", "{}")) return " ".join(messages)
def get_summary(self) -> str: """Get summarized report. :return: Short summary of why the step is dirty. :rtype: str """ reasons = [] if self.previous_step_modified: reasons.append("{!r} step".format( self.previous_step_modified.name)) if self.source_updated: reasons.append("source") return "{} changed".format( formatting_utils.humanize_list(reasons, "and", "{}"))
def summary(self) -> str: """Get summarized report. :return: Short summary of why the part is dirty. :rtype: str """ reasons = [] reasons_count = 0 if self.dirty_properties: reasons_count += 1 if self.dirty_project_options: reasons_count += 1 if self.changed_dependencies: reasons_count += 1 if self.dirty_properties: # Be specific only if this is the only reason if reasons_count > 1 or len(self.dirty_properties) > 1: reasons.append("properties") else: reasons.append("{!r} property".format( next(iter(self.dirty_properties)))) if self.dirty_project_options: # Be specific only if this is the only reason if reasons_count > 1 or len(self.dirty_project_options) > 1: reasons.append("options") else: reasons.append("{!r} option".format( next(iter(self.dirty_project_options)))) if self.changed_dependencies: # Be specific only if this is the only reason if reasons_count > 1 or len(self.changed_dependencies) > 1: reasons.append("dependencies") else: reasons.append("{!r}".format( next(iter(self.changed_dependencies)).part_name)) return "{} changed".format( formatting_utils.humanize_list(reasons, "and", "{}"))
def _clean_parts(part_names, step, config, staged_state, primed_state): if not step: step = steps.next_step(None) for part_name in part_names: dirty_parts = _clean_part(part_name, step, config, staged_state, primed_state) dirty_part_names = {p.name for p in dirty_parts} parts_not_being_cleaned = dirty_part_names.difference(part_names) if parts_not_being_cleaned: logger.warning( "Cleaned {!r}, which makes the following {} out of date: " "{}".format( part_name, formatting_utils.pluralize(parts_not_being_cleaned, "part", "parts"), formatting_utils.humanize_list(parts_not_being_cleaned, "and"), ))
def __init__(self, *, architecture: str, supported: List[str]) -> None: super().__init__( architecture=architecture, supported=formatting_utils.humanize_list(supported, "and"), )
def __init__(self, source_type: str, options: List[str]) -> None: self.options = options super().__init__( source_type=source_type, humanized_options=formatting_utils.humanize_list(options, "and"), )