4135

pending completion

Build # 4135

Build Type

Pull #959

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #1029 from great-expectations/aylr/i-dont-like-you-legacy-python

WIP * legacy python test fix attempts

Pull Request Pull Request #959: 0.9.0

Run Details

4152 of 4152 new or added lines in 81 files covered. (100.0%)

8795 of 11422 relevant lines covered (77.0%)

3.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

65.17

/great_expectations/core/metric.py

from great_expectations.core.data_context_key import DataContextKey
from great_expectations.core.id_dict import IDDict
from great_expectations.data_context.types.resource_identifiers import ExpectationSuiteIdentifier
from great_expectations.exceptions import GreatExpectationsError


class Metric(object):
    """A Metric associates a value with some name and configuration. The specific configuration parameters that are
    relevant for a given metric's identity depend on the metric. For example, the metric `column_mean` depends on a
    column name.
    """
    def __init__(self, metric_name, metric_kwargs, metric_value):
        self._metric_name = metric_name
        if not isinstance(metric_kwargs, IDDict):
            metric_kwargs = IDDict(metric_kwargs)
        self._metric_kwargs = metric_kwargs
        self._metric_value = metric_value

    @property
    def metric_name(self):
        return self._metric_name

    @property
    def metric_kwargs(self):
        return self._metric_kwargs

    @property
    def metric_kwargs_id(self):
        return self._metric_kwargs.to_id()


class MetricIdentifier(DataContextKey):
    """A MetricIdentifier serves as a key to store and retrieve Metrics."""
    def __init__(self, metric_name, metric_kwargs_id):
        self._metric_name = metric_name
        if metric_kwargs_id is None:
            metric_kwargs_id = "__"  # This is a placeholder
        self._metric_kwargs_id = metric_kwargs_id

    @property
    def metric_name(self):
        return self._metric_name

    @property
    def metric_kwargs_id(self):
        if self._metric_kwargs_id == "__":
            return None
        return self._metric_kwargs_id

    @classmethod
    def from_object(cls, metric):
        if not isinstance(metric, Metric):
            raise GreatExpectationsError("Unable to build MetricIdentifier from object of type {} when Metric is "
                                         "expected.".format(type(metric)))
        return cls(metric.metric_name, metric.metric_kwargs_id)

    def to_fixed_length_tuple(self):
        return self.to_tuple()

    def to_tuple(self):
        return tuple((self.metric_name, self._metric_kwargs_id))  # We use the placeholder in to_tuple

    @classmethod
    def from_fixed_length_tuple(cls, tuple_):
        return cls.from_tuple(tuple_)

    @classmethod
    def from_tuple(cls, tuple_):
        return cls(*tuple_)


class BatchMetric(Metric):
    """A BatchMetric is a metric associated with a particular Batch of data."""
    def __init__(self, metric_name, metric_kwargs, batch_identifier, metric_value):
        super(BatchMetric, self).__init__(metric_name, metric_kwargs, metric_value)
        self._batch_identifier = batch_identifier

    @property
    def batch_identifier(self):
        return self._batch_identifier


class ValidationMetric(Metric):
    def __init__(self, run_id, expectation_suite_identifier, metric_name, metric_kwargs, metric_value):
        super(ValidationMetric, self).__init__(metric_name, metric_kwargs, metric_value)
        if not isinstance(expectation_suite_identifier, ExpectationSuiteIdentifier):
            expectation_suite_identifier = ExpectationSuiteIdentifier(
                expectation_suite_name=expectation_suite_identifier)
        self._run_id = run_id
        self._expectation_suite_identifier = expectation_suite_identifier

    @property
    def run_id(self):
        return self._run_id

    @property
    def expectation_suite_identifier(self):
        return self._expectation_suite_identifier


class ValidationMetricIdentifier(MetricIdentifier):

    def __init__(self, run_id, expectation_suite_identifier, metric_name, metric_kwargs_id):
        super(ValidationMetricIdentifier, self).__init__(metric_name, metric_kwargs_id)
        if not isinstance(expectation_suite_identifier, ExpectationSuiteIdentifier):
            expectation_suite_identifier = ExpectationSuiteIdentifier(
                expectation_suite_name=expectation_suite_identifier)
        self._run_id = run_id
        self._expectation_suite_identifier = expectation_suite_identifier

    @property
    def run_id(self):
        return self._run_id

    @property
    def expectation_suite_identifier(self):
        return self._expectation_suite_identifier

    @classmethod
    def from_object(cls, validation_metric):
        if not isinstance(validation_metric, ValidationMetric):
            raise GreatExpectationsError("Unable to build ValidationMetricIdentifier from object of type {} when "
                                         "ValidationMetric is expected.".format(type(validation_metric)))

        return cls(validation_metric.expectation_suite_identifier, validation_metric.run_id,
                   validation_metric.metric_name, validation_metric.metric_kwargs_id)

    def to_tuple(self):
        # Note use of _metric_kwargs_id instead of metric_kwargs_id to preserve no None semantics
        return tuple([self.run_id] + list(self.expectation_suite_identifier.to_tuple()) + [self.metric_name,
                     self._metric_kwargs_id])

    def to_fixed_length_tuple(self):
        # Note use of _metric_kwargs_id instead of metric_kwargs_id to preserve no None semantics
        return tuple([self.run_id] + list(self.expectation_suite_identifier.to_fixed_length_tuple()) +
                     [self.metric_name, self._metric_kwargs_id])

    def to_evaluation_parameter_urn(self):
        if self._metric_kwargs_id == "__":
            return "urn:great_expectations:validations:" + ":".join(
                list(self.expectation_suite_identifier.to_fixed_length_tuple()) + [self.metric_name]
            )
        else:
            return "urn:great_expectations:validations:" + ":".join(
                list(self.expectation_suite_identifier.to_fixed_length_tuple()) +
                [self.metric_name, self.metric_kwargs_id]
            )

    @classmethod
    def from_tuple(cls, tuple_):
        if len(tuple_) < 4:
            raise GreatExpectationsError("ValidationMetricIdentifier tuple must have at least four components.")
        return cls(
            run_id=tuple_[0],
            expectation_suite_identifier=ExpectationSuiteIdentifier.from_tuple(tuple_[1:-2]),
            metric_name=tuple_[-2],
            metric_kwargs_id=tuple_[-1]
        )

    @classmethod
    def from_fixed_length_tuple(cls, tuple_):
        if len(tuple_) != 4:
            raise GreatExpectationsError("ValidationMetricIdentifier fixed length tuple must have exactly four "
                                         "components.")
        return cls(
            run_id=tuple_[0],
            expectation_suite_identifier=ExpectationSuiteIdentifier.from_fixed_length_tuple(tuple((tuple_[1],))),
            metric_name=tuple_[2],
            metric_kwargs_id=tuple_[3]
        )

1	from great_expectations.core.data_context_key import DataContextKey	5✔
2	from great_expectations.core.id_dict import IDDict	5✔
3	from great_expectations.data_context.types.resource_identifiers import ExpectationSuiteIdentifier	5✔
4	from great_expectations.exceptions import GreatExpectationsError	5✔
5
6
7	class Metric(object):	5✔
8	"""A Metric associates a value with some name and configuration. The specific configuration parameters that are
9	relevant for a given metric's identity depend on the metric. For example, the metric `column_mean` depends on a
10	column name.
11	"""
12	def __init__(self, metric_name, metric_kwargs, metric_value):	5✔
13	self._metric_name = metric_name	×
14	if not isinstance(metric_kwargs, IDDict):	×
15	metric_kwargs = IDDict(metric_kwargs)	×
16	self._metric_kwargs = metric_kwargs	×
17	self._metric_value = metric_value	×
18
19	@property	5✔
20	def metric_name(self):
21	return self._metric_name	×
22
23	@property	5✔
24	def metric_kwargs(self):
25	return self._metric_kwargs	×
26
27	@property	5✔
28	def metric_kwargs_id(self):
29	return self._metric_kwargs.to_id()	×
30
31
32	class MetricIdentifier(DataContextKey):	5✔
33	"""A MetricIdentifier serves as a key to store and retrieve Metrics."""
34	def __init__(self, metric_name, metric_kwargs_id):	5✔
35	self._metric_name = metric_name	5✔
36	if metric_kwargs_id is None:	5✔
37	metric_kwargs_id = "__" # This is a placeholder	5✔
38	self._metric_kwargs_id = metric_kwargs_id	5✔
39
40	@property	5✔
41	def metric_name(self):
42	return self._metric_name	5✔
43
44	@property	5✔
45	def metric_kwargs_id(self):
46	if self._metric_kwargs_id == "__":	5✔
47	return None	×
48	return self._metric_kwargs_id	5✔
49
50	@classmethod	5✔
51	def from_object(cls, metric):
52	if not isinstance(metric, Metric):	×
53	raise GreatExpectationsError("Unable to build MetricIdentifier from object of type {} when Metric is "	×
54	"expected.".format(type(metric)))
55	return cls(metric.metric_name, metric.metric_kwargs_id)	×
56
57	def to_fixed_length_tuple(self):	5✔
58	return self.to_tuple()	×
59
60	def to_tuple(self):	5✔
61	return tuple((self.metric_name, self._metric_kwargs_id)) # We use the placeholder in to_tuple	×
62
63	@classmethod	5✔
64	def from_fixed_length_tuple(cls, tuple_):
65	return cls.from_tuple(tuple_)	×
66
67	@classmethod	5✔
68	def from_tuple(cls, tuple_):
69	return cls(*tuple_)	×
70
71
72	class BatchMetric(Metric):	5✔
73	"""A BatchMetric is a metric associated with a particular Batch of data."""
74	def __init__(self, metric_name, metric_kwargs, batch_identifier, metric_value):	5✔
75	super(BatchMetric, self).__init__(metric_name, metric_kwargs, metric_value)	×
76	self._batch_identifier = batch_identifier	×
77
78	@property	5✔
79	def batch_identifier(self):
80	return self._batch_identifier	×
81
82
83	class ValidationMetric(Metric):	5✔
84	def __init__(self, run_id, expectation_suite_identifier, metric_name, metric_kwargs, metric_value):	5✔
85	super(ValidationMetric, self).__init__(metric_name, metric_kwargs, metric_value)	×
86	if not isinstance(expectation_suite_identifier, ExpectationSuiteIdentifier):	×
87	expectation_suite_identifier = ExpectationSuiteIdentifier(	×
88	expectation_suite_name=expectation_suite_identifier)
89	self._run_id = run_id	×
90	self._expectation_suite_identifier = expectation_suite_identifier	×
91
92	@property	5✔
93	def run_id(self):
94	return self._run_id	×
95
96	@property	5✔
97	def expectation_suite_identifier(self):
98	return self._expectation_suite_identifier	×
99
100
101	class ValidationMetricIdentifier(MetricIdentifier):	5✔
102
103	def __init__(self, run_id, expectation_suite_identifier, metric_name, metric_kwargs_id):	5✔
104	super(ValidationMetricIdentifier, self).__init__(metric_name, metric_kwargs_id)	5✔
105	if not isinstance(expectation_suite_identifier, ExpectationSuiteIdentifier):	5✔
106	expectation_suite_identifier = ExpectationSuiteIdentifier(	5✔
107	expectation_suite_name=expectation_suite_identifier)
108	self._run_id = run_id	5✔
109	self._expectation_suite_identifier = expectation_suite_identifier	5✔
110
111	@property	5✔
112	def run_id(self):
113	return self._run_id	5✔
114
115	@property	5✔
116	def expectation_suite_identifier(self):
117	return self._expectation_suite_identifier	5✔
118
119	@classmethod	5✔
120	def from_object(cls, validation_metric):
121	if not isinstance(validation_metric, ValidationMetric):	×
122	raise GreatExpectationsError("Unable to build ValidationMetricIdentifier from object of type {} when "	×
123	"ValidationMetric is expected.".format(type(validation_metric)))
124
125	return cls(validation_metric.expectation_suite_identifier, validation_metric.run_id,	×
126	validation_metric.metric_name, validation_metric.metric_kwargs_id)
127
128	def to_tuple(self):	5✔
129	# Note use of _metric_kwargs_id instead of metric_kwargs_id to preserve no None semantics
130	return tuple([self.run_id] + list(self.expectation_suite_identifier.to_tuple()) + [self.metric_name,	5✔
131	self._metric_kwargs_id])
132
133	def to_fixed_length_tuple(self):	5✔
134	# Note use of _metric_kwargs_id instead of metric_kwargs_id to preserve no None semantics
135	return tuple([self.run_id] + list(self.expectation_suite_identifier.to_fixed_length_tuple()) +	5✔
136	[self.metric_name, self._metric_kwargs_id])
137
138	def to_evaluation_parameter_urn(self):	5✔
139	if self._metric_kwargs_id == "__":	5✔
140	return "urn:great_expectations:validations:" + ":".join(	5✔
141	list(self.expectation_suite_identifier.to_fixed_length_tuple()) + [self.metric_name]
142	)
143	else:
144	return "urn:great_expectations:validations:" + ":".join(	5✔
145	list(self.expectation_suite_identifier.to_fixed_length_tuple()) +
146	[self.metric_name, self.metric_kwargs_id]
147	)
148
149	@classmethod	5✔
150	def from_tuple(cls, tuple_):
151	if len(tuple_) < 4:	5✔
152	raise GreatExpectationsError("ValidationMetricIdentifier tuple must have at least four components.")	×
153	return cls(	5✔
154	run_id=tuple_[0],
155	expectation_suite_identifier=ExpectationSuiteIdentifier.from_tuple(tuple_[1:-2]),
156	metric_name=tuple_[-2],
157	metric_kwargs_id=tuple_[-1]
158	)
159
160	@classmethod	5✔
161	def from_fixed_length_tuple(cls, tuple_):
162	if len(tuple_) != 4:	5✔
163	raise GreatExpectationsError("ValidationMetricIdentifier fixed length tuple must have exactly four "	×
164	"components.")
165	return cls(	5✔
166	run_id=tuple_[0],
167	expectation_suite_identifier=ExpectationSuiteIdentifier.from_fixed_length_tuple(tuple((tuple_[1],))),
168	metric_name=tuple_[2],
169	metric_kwargs_id=tuple_[3]
170	)

great-expectations / great_expectations / 4135

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous