Skip to content

Human-readable formatter

Human readable formatter.

HumanReadableFormatter

Bases: Formatter

Formatter for human-readable messages in the terminal.

Source code in src/dbt_score/formatters/human_readable_formatter.py 
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
class HumanReadableFormatter(Formatter):
    """Formatter for human-readable messages in the terminal."""

    indent = "    "
    label_ok = "\033[1;32mOK  \033[0m"
    label_warning = "\033[1;33mWARN\033[0m"
    label_error = "\033[1;31mERR \033[0m"

    def __init__(self, *args: Any, **kwargs: Any):
        """Instantiate formatter."""
        super().__init__(*args, **kwargs)
        self._failed_evaluables: list[tuple[Evaluable, Score]] = []

    @staticmethod
    def bold(text: str) -> str:
        """Return text in bold."""
        return f"\033[1m{text}\033[0m"

    @staticmethod
    def pretty_name(evaluable: Evaluable) -> str:
        """Return the pretty name for an evaluable."""
        match evaluable:
            case Model():
                return evaluable.name
            case Source():
                return evaluable.selector_name
            case Snapshot():
                return evaluable.name
            case Exposure():
                return evaluable.name
            case Seed():
                return evaluable.name
            case Macro():
                return evaluable.name
            case _:
                raise NotImplementedError

    def evaluable_evaluated(
        self, evaluable: Evaluable, results: EvaluableResultsType, score: Score
    ) -> None:
        """Callback when an evaluable item has been evaluated."""
        if evaluable_failed := score.value < self._config.fail_any_item_under:
            self._failed_evaluables.append((evaluable, score))
        if (
            evaluable_failed
            or self._config.show == "all"
            or (
                self._config.show not in ["failing-items"]
                and any(result is not None for result in results.values())
            )
        ):
            resource_type = type(evaluable).__name__
            name_formatted = f"{resource_type}: {self.pretty_name(evaluable)}"
            header = (
                f"{score.badge} "
                f"{self.bold(name_formatted)} (score: {score.rounded_value!s})"
            )

            print(header)
            for rule, result in results.items():
                if result is None:
                    if self._config.show in ["all"]:
                        print(f"{self.indent}{self.label_ok} {rule.source()}")
                elif isinstance(result, RuleViolation):
                    print(
                        f"{self.indent}{self.label_warning} "
                        f"({rule.severity.name.lower()}) {rule.source()}: "
                        f"{result.message}"
                    )
                else:
                    print(
                        f"{self.indent}{self.label_error} {rule.source()}: {result!s}"
                    )
            print()

    def project_evaluated(self, score: Score) -> None:
        """Callback when a project has been evaluated."""
        print(f"Project score: {self.bold(str(score.rounded_value))} {score.badge}")

        if len(self._failed_evaluables) > 0:
            print()
            print(
                f"Error: evaluable score too low, fail_any_item_under = "
                f"{self._config.fail_any_item_under}"
            )
            for evaluable, evaluable_score in self._failed_evaluables:
                resource_type = type(evaluable)
                print(
                    f"{resource_type.__name__} {self.pretty_name(evaluable)} "
                    f"scored {evaluable_score.rounded_value}"
                )

        elif score.value < self._config.fail_project_under:
            print()
            print(
                f"Error: project score too low, fail_project_under = "
                f"{self._config.fail_project_under}"
            )

__init__(*args, **kwargs)

Instantiate formatter.

Source code in src/dbt_score/formatters/human_readable_formatter.py 
20
21
22
23
def __init__(self, *args: Any, **kwargs: Any):
    """Instantiate formatter."""
    super().__init__(*args, **kwargs)
    self._failed_evaluables: list[tuple[Evaluable, Score]] = []

bold(text) staticmethod

Return text in bold.

Source code in src/dbt_score/formatters/human_readable_formatter.py 
25
26
27
28
@staticmethod
def bold(text: str) -> str:
    """Return text in bold."""
    return f"\033[1m{text}\033[0m"

evaluable_evaluated(evaluable, results, score)

Callback when an evaluable item has been evaluated.

Source code in src/dbt_score/formatters/human_readable_formatter.py 
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
def evaluable_evaluated(
    self, evaluable: Evaluable, results: EvaluableResultsType, score: Score
) -> None:
    """Callback when an evaluable item has been evaluated."""
    if evaluable_failed := score.value < self._config.fail_any_item_under:
        self._failed_evaluables.append((evaluable, score))
    if (
        evaluable_failed
        or self._config.show == "all"
        or (
            self._config.show not in ["failing-items"]
            and any(result is not None for result in results.values())
        )
    ):
        resource_type = type(evaluable).__name__
        name_formatted = f"{resource_type}: {self.pretty_name(evaluable)}"
        header = (
            f"{score.badge} "
            f"{self.bold(name_formatted)} (score: {score.rounded_value!s})"
        )

        print(header)
        for rule, result in results.items():
            if result is None:
                if self._config.show in ["all"]:
                    print(f"{self.indent}{self.label_ok} {rule.source()}")
            elif isinstance(result, RuleViolation):
                print(
                    f"{self.indent}{self.label_warning} "
                    f"({rule.severity.name.lower()}) {rule.source()}: "
                    f"{result.message}"
                )
            else:
                print(
                    f"{self.indent}{self.label_error} {rule.source()}: {result!s}"
                )
        print()

pretty_name(evaluable) staticmethod

Return the pretty name for an evaluable.

Source code in src/dbt_score/formatters/human_readable_formatter.py 
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
@staticmethod
def pretty_name(evaluable: Evaluable) -> str:
    """Return the pretty name for an evaluable."""
    match evaluable:
        case Model():
            return evaluable.name
        case Source():
            return evaluable.selector_name
        case Snapshot():
            return evaluable.name
        case Exposure():
            return evaluable.name
        case Seed():
            return evaluable.name
        case Macro():
            return evaluable.name
        case _:
            raise NotImplementedError

project_evaluated(score)

Callback when a project has been evaluated.

Source code in src/dbt_score/formatters/human_readable_formatter.py 
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
def project_evaluated(self, score: Score) -> None:
    """Callback when a project has been evaluated."""
    print(f"Project score: {self.bold(str(score.rounded_value))} {score.badge}")

    if len(self._failed_evaluables) > 0:
        print()
        print(
            f"Error: evaluable score too low, fail_any_item_under = "
            f"{self._config.fail_any_item_under}"
        )
        for evaluable, evaluable_score in self._failed_evaluables:
            resource_type = type(evaluable)
            print(
                f"{resource_type.__name__} {self.pretty_name(evaluable)} "
                f"scored {evaluable_score.rounded_value}"
            )

    elif score.value < self._config.fail_project_under:
        print()
        print(
            f"Error: project score too low, fail_project_under = "
            f"{self._config.fail_project_under}"
        )