Skip to content

result

mlte/validation/result.py

The result of measurement validation.

Failure

Bases: Result

Indicates failed measurement validation.

Source code in mlte/validation/result.py 
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
class Failure(Result):
    """Indicates failed measurement validation."""

    def __init__(self, message: str = ""):
        """
        Initialize a Failure validation result instance.

        :param message: Optional message
        """
        super().__init__(message)

    def __bool__(self) -> bool:
        """Implicit boolean conversion."""
        return False

    def __str__(self) -> str:
        """String representation."""
        return "Failure"

__bool__()

Implicit boolean conversion.

Source code in mlte/validation/result.py 
128
129
130
def __bool__(self) -> bool:
    """Implicit boolean conversion."""
    return False

__init__(message='')

Initialize a Failure validation result instance.

Parameters:

Name Type Description Default
message str

Optional message

 ''
Source code in mlte/validation/result.py 
120
121
122
123
124
125
126
def __init__(self, message: str = ""):
    """
    Initialize a Failure validation result instance.

    :param message: Optional message
    """
    super().__init__(message)

__str__()

String representation.

Source code in mlte/validation/result.py 
132
133
134
def __str__(self) -> str:
    """String representation."""
    return "Failure"

Info

Bases: Result

Indicates an informational resut of measurement validation, not validated.

Source code in mlte/validation/result.py 
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
class Info(Result):
    """Indicates an informational resut of measurement validation, not validated."""

    def __init__(self, message: str):
        """
        Initialize an Info validatation result instance.

        :param message: Message indicating the reason validation is info
        """
        super().__init__(message)

    def __bool__(self) -> bool:
        """Implicit boolean conversion."""
        raise RuntimeError("Boolean conversion for Info() is ambiguous.")

    def __str__(self) -> str:
        """String representation."""
        return "Info"

__bool__()

Implicit boolean conversion.

Source code in mlte/validation/result.py 
148
149
150
def __bool__(self) -> bool:
    """Implicit boolean conversion."""
    raise RuntimeError("Boolean conversion for Info() is ambiguous.")

__init__(message)

Initialize an Info validatation result instance.

Parameters:

Name Type Description Default
message str

Message indicating the reason validation is info

 required
Source code in mlte/validation/result.py 
140
141
142
143
144
145
146
def __init__(self, message: str):
    """
    Initialize an Info validatation result instance.

    :param message: Message indicating the reason validation is info
    """
    super().__init__(message)

__str__()

String representation.

Source code in mlte/validation/result.py 
152
153
154
def __str__(self) -> str:
    """String representation."""
    return "Info"

Result

The base class for measurement validation results.

Source code in mlte/validation/result.py 
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
class Result(metaclass=abc.ABCMeta):
    """The base class for measurement validation results."""

    @classmethod
    def __subclasshook__(cls, subclass):
        """Define the interface for all concrete Result."""
        return meta.has_callables(subclass, "__bool__", "__str__")

    def __init__(self, message: str):
        """
        Initialize a Result instance.
        """

        self.message = message
        """The message indicating the reason for status."""

        self.metadata: Optional[EvidenceMetadata] = None
        """
        The information about the measurement from which this was obtained.
        """

    def _with_evidence_metadata(
        self, evidence_metadata: EvidenceMetadata
    ) -> Result:
        """
        Set the `metadata` field of the Result
        to indicate the evidence metadata info from which
        it was generated.

        This hook allows us to embed the evidence metadata within
        the Result so that we can use the metadata
        information later when it is used to generate a report.

        :param evidence_metadata: The evidence metadata of the
        Value from which was this instance was generated.
        :return: The Result instance (`self`)
        """
        self.metadata = evidence_metadata
        return self

    def to_model(self) -> ResultModel:
        """
        Returns this object as a model

        :return: The model.
        """
        return ResultModel(
            type=f"{self}", message=self.message, metadata=self.metadata
        )

    @classmethod
    def from_model(cls, model: ResultModel) -> Result:
        """
        Returns a result from a model.

        :param model: The model
        :return: The deserialized object.
        """
        result_type = model.type
        results_module = sys.modules[__name__]
        result_class = getattr(results_module, result_type)

        result: Result = result_class(model.message)
        if model.metadata is not None:
            result = result._with_evidence_metadata(model.metadata)
        return result

    def __eq__(self, other: object) -> bool:
        """Equality comparison."""
        assert self.metadata is not None, "Broken precondition."
        if not isinstance(other, Result):
            return False
        return self.to_model() == other.to_model()

message = message instance-attribute

The message indicating the reason for status.

metadata = None instance-attribute

The information about the measurement from which this was obtained.

__eq__(other)

Equality comparison.

Source code in mlte/validation/result.py 
89
90
91
92
93
94
def __eq__(self, other: object) -> bool:
    """Equality comparison."""
    assert self.metadata is not None, "Broken precondition."
    if not isinstance(other, Result):
        return False
    return self.to_model() == other.to_model()

__init__(message)

Initialize a Result instance.

Source code in mlte/validation/result.py 
30
31
32
33
34
35
36
37
38
39
40
41
def __init__(self, message: str):
    """
    Initialize a Result instance.
    """

    self.message = message
    """The message indicating the reason for status."""

    self.metadata: Optional[EvidenceMetadata] = None
    """
    The information about the measurement from which this was obtained.
    """

__subclasshook__(subclass) classmethod

Define the interface for all concrete Result.

Source code in mlte/validation/result.py 
25
26
27
28
@classmethod
def __subclasshook__(cls, subclass):
    """Define the interface for all concrete Result."""
    return meta.has_callables(subclass, "__bool__", "__str__")

from_model(model) classmethod

Returns a result from a model.

Parameters:

Name Type Description Default
model ResultModel

The model

 required

Returns:

Type Description
Result

The deserialized object.
Source code in mlte/validation/result.py 
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
@classmethod
def from_model(cls, model: ResultModel) -> Result:
    """
    Returns a result from a model.

    :param model: The model
    :return: The deserialized object.
    """
    result_type = model.type
    results_module = sys.modules[__name__]
    result_class = getattr(results_module, result_type)

    result: Result = result_class(model.message)
    if model.metadata is not None:
        result = result._with_evidence_metadata(model.metadata)
    return result

to_model()

Returns this object as a model

Returns:

Type Description
ResultModel

The model.
Source code in mlte/validation/result.py 
62
63
64
65
66
67
68
69
70
def to_model(self) -> ResultModel:
    """
    Returns this object as a model

    :return: The model.
    """
    return ResultModel(
        type=f"{self}", message=self.message, metadata=self.metadata
    )

Success

Bases: Result

Indicates successful measurement validation.

Source code in mlte/validation/result.py 
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
class Success(Result):
    """Indicates successful measurement validation."""

    def __init__(self, message: str = ""):
        """
        Initialize a Success validation result instance.

        :param message: Optional message
        """
        super().__init__(message)

    def __bool__(self) -> bool:
        """Implicit boolean conversion."""
        return True

    def __str__(self) -> str:
        """String representation."""
        return "Success"

__bool__()

Implicit boolean conversion.

Source code in mlte/validation/result.py 
108
109
110
def __bool__(self) -> bool:
    """Implicit boolean conversion."""
    return True

__init__(message='')

Initialize a Success validation result instance.

Parameters:

Name Type Description Default
message str

Optional message

 ''
Source code in mlte/validation/result.py 
100
101
102
103
104
105
106
def __init__(self, message: str = ""):
    """
    Initialize a Success validation result instance.

    :param message: Optional message
    """
    super().__init__(message)

__str__()

String representation.

Source code in mlte/validation/result.py 
112
113
114
def __str__(self) -> str:
    """String representation."""
    return "Success"