Skip to content

result

The result of measurement validation.

Failure

Bases: Result

Indicates failed measurement validation.

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

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

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

    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/results/result.py 
126
127
128
def __bool__(self) -> bool:
    """Implicit boolean conversion."""
    return False

__init__(message='', additional_data='')

Initialize a Failure validation result instance.

Parameters:

Name Type Description Default
message str

Optional message

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

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

__str__()

String representation.

Source code in mlte/results/result.py 
130
131
132
def __str__(self) -> str:
    """String representation."""
    return "Failure"

Info

Bases: Result

Indicates an informational resut of measurement validation, not validated.

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

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

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

    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/results/result.py 
146
147
148
def __bool__(self) -> bool:
    """Implicit boolean conversion."""
    raise RuntimeError("Boolean conversion for Info() is ambiguous.")

__init__(message, additional_data='')

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/results/result.py 
138
139
140
141
142
143
144
def __init__(self, message: str, additional_data: str = ""):
    """
    Initialize an Info validatation result instance.

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

__str__()

String representation.

Source code in mlte/results/result.py 
150
151
152
def __str__(self) -> str:
    """String representation."""
    return "Info"

Result

Bases: ABC

The base class for measurement validation results.

Source code in mlte/results/result.py 
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
class Result(ABC):
    """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, additional_data: str = ""):
        """Initialize a Result instance."""

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

        self.additional_data = additional_data
        """Additional details to complement the message, if any."""

        self.evidence_metadata: Optional[EvidenceMetadata] = None
        """
        The measurement id from which this was obtained.
        """

    def _with_evidence_metadata(
        self, evidence_metadata: Optional[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 to be added.
        :return: The Result instance (`self`)
        """
        self.evidence_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,
            additional_data=self.additional_data,
            evidence_metadata=self.evidence_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, model.additional_data)
        result = result._with_evidence_metadata(model.evidence_metadata)
        return result

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

additional_data = additional_data instance-attribute

Additional details to complement the message, if any.

evidence_metadata = None instance-attribute

The measurement id from which this was obtained.

message = message instance-attribute

The message indicating the reason for status.

__eq__(other)

Equality comparison.

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

__init__(message, additional_data='')

Initialize a Result instance.

Source code in mlte/results/result.py 
26
27
28
29
30
31
32
33
34
35
36
37
38
def __init__(self, message: str, additional_data: str = ""):
    """Initialize a Result instance."""

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

    self.additional_data = additional_data
    """Additional details to complement the message, if any."""

    self.evidence_metadata: Optional[EvidenceMetadata] = None
    """
    The measurement id from which this was obtained.
    """

__subclasshook__(subclass) classmethod

Define the interface for all concrete Result.

Source code in mlte/results/result.py 
21
22
23
24
@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/results/result.py 
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
@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, model.additional_data)
    result = result._with_evidence_metadata(model.evidence_metadata)
    return result

to_model()

Returns this object as a model

Returns:

Type Description
ResultModel

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

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

Success

Bases: Result

Indicates successful measurement validation.

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

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

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

    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/results/result.py 
106
107
108
def __bool__(self) -> bool:
    """Implicit boolean conversion."""
    return True

__init__(message='', additional_data='')

Initialize a Success validation result instance.

Parameters:

Name Type Description Default
message str

Optional message

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

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

__str__()

String representation.

Source code in mlte/results/result.py 
110
111
112
def __str__(self) -> str:
    """String representation."""
    return "Success"