4960

pending completion

Build # 4960

Build Type

Pull #1240

travis-ci

Committed by

web-flow

Commit Message

Typo fixed.

Pull Request Pull Request #1240: Alexsherstinsky/error messages improvements 03 24 2020

Run Details

222 of 222 new or added lines in 27 files covered. (100.0%)

9449 of 12191 relevant lines covered (77.51%)

2.32 hits per line

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

90.91

/great_expectations/data_context/store/store.py

import logging

from great_expectations.core.data_context_key import DataContextKey
from great_expectations.data_context.store.store_backend import StoreBackend
from great_expectations.data_context.util import instantiate_class_from_config
from great_expectations.exceptions import (
    DataContextError,
    ClassInstantiationError,
)

logger = logging.getLogger(__name__)


class Store(object):
    """A store is responsible for reading and writing Great Expectations objects
    to appropriate backends. It provides a generic API that the DataContext can
    use independently of any particular ORM and backend.

    An implementation of a store will generally need to define the following:
      - serialize
      - deserialize
      - _key_class (class of expected key type)

    All keys must have a to_tuple() method.
    """
    _key_class = DataContextKey

    def __init__(self, store_backend=None, runtime_environment=None):
        """Runtime environment may be necessary to instantiate store backend elements."""
        if store_backend is None:
            store_backend = {
                "class_name": "InMemoryStoreBackend"
            }
        logger.debug("Building store_backend.")
        module_name = 'great_expectations.data_context.store'
        self._store_backend = instantiate_class_from_config(
            config=store_backend,
            runtime_environment=runtime_environment or {},
            config_defaults={
                "module_name": module_name
            }
        )
        if not self._store_backend:
            raise ClassInstantiationError(
                module_name=module_name,
                package_name=None,
                class_name=store_backend
            )
        if not isinstance(self._store_backend, StoreBackend):
            raise DataContextError("Invalid StoreBackend configuration: expected a StoreBackend instance.")
        self._use_fixed_length_key = self._store_backend.fixed_length_key

    def _validate_key(self, key):
        if not isinstance(key, self._key_class):
            raise TypeError("key must be an instance of %s, not %s" % (self._key_class.__name__, type(key)))

    # noinspection PyMethodMayBeStatic
    def serialize(self, key, value):
        return value

    # noinspection PyMethodMayBeStatic
    def key_to_tuple(self, key):
        if self._use_fixed_length_key:
            return key.to_fixed_length_tuple()
        return key.to_tuple()

    def tuple_to_key(self, tuple_):
        if self._use_fixed_length_key:
            return self._key_class.from_fixed_length_tuple(tuple_)
        return self._key_class.from_tuple(tuple_)

    # noinspection PyMethodMayBeStatic
    def deserialize(self, key, value):
        return value

    def get(self, key):
        self._validate_key(key)
        return self.deserialize(key, self._store_backend.get(self.key_to_tuple(key)))

    def set(self, key, value):
        self._validate_key(key)
        return self._store_backend.set(self.key_to_tuple(key), self.serialize(key, value))

    def list_keys(self):
        return [self.tuple_to_key(key) for key in self._store_backend.list_keys()]

    def has_key(self, key):
        return self._store_backend.has_key(key.to_tuple())

1	import logging	3✔
2
3	from great_expectations.core.data_context_key import DataContextKey	3✔
4	from great_expectations.data_context.store.store_backend import StoreBackend	3✔
5	from great_expectations.data_context.util import instantiate_class_from_config	3✔
6	from great_expectations.exceptions import (	3✔
7	DataContextError,
8	ClassInstantiationError,
9	)
10
11	logger = logging.getLogger(__name__)	3✔
12
13
14	class Store(object):	3✔
15	"""A store is responsible for reading and writing Great Expectations objects
16	to appropriate backends. It provides a generic API that the DataContext can
17	use independently of any particular ORM and backend.
18
19	An implementation of a store will generally need to define the following:
20	- serialize
21	- deserialize
22	- _key_class (class of expected key type)
23
24	All keys must have a to_tuple() method.
25	"""
26	_key_class = DataContextKey	3✔
27
28	def __init__(self, store_backend=None, runtime_environment=None):	3✔
29	"""Runtime environment may be necessary to instantiate store backend elements."""
30	if store_backend is None:	3✔
31	store_backend = {	3✔
32	"class_name": "InMemoryStoreBackend"
33	}
34	logger.debug("Building store_backend.")	3✔
35	module_name = 'great_expectations.data_context.store'	3✔
36	self._store_backend = instantiate_class_from_config(	3✔
37	config=store_backend,
38	runtime_environment=runtime_environment or {},
39	config_defaults={
40	"module_name": module_name
41	}
42	)
43	if not self._store_backend:	3✔
44	raise ClassInstantiationError(	×
45	module_name=module_name,
46	package_name=None,
47	class_name=store_backend
48	)
49	if not isinstance(self._store_backend, StoreBackend):	3✔
50	raise DataContextError("Invalid StoreBackend configuration: expected a StoreBackend instance.")	×
51	self._use_fixed_length_key = self._store_backend.fixed_length_key	3✔
52
53	def _validate_key(self, key):	3✔
54	if not isinstance(key, self._key_class):	3✔
55	raise TypeError("key must be an instance of %s, not %s" % (self._key_class.__name__, type(key)))	3✔
56
57	# noinspection PyMethodMayBeStatic
58	def serialize(self, key, value):	3✔
59	return value	×
60
61	# noinspection PyMethodMayBeStatic
62	def key_to_tuple(self, key):	3✔
63	if self._use_fixed_length_key:	3✔
64	return key.to_fixed_length_tuple()	3✔
65	return key.to_tuple()	3✔
66
67	def tuple_to_key(self, tuple_):	3✔
68	if self._use_fixed_length_key:	3✔
69	return self._key_class.from_fixed_length_tuple(tuple_)	3✔
70	return self._key_class.from_tuple(tuple_)	3✔
71
72	# noinspection PyMethodMayBeStatic
73	def deserialize(self, key, value):	3✔
74	return value	×
75
76	def get(self, key):	3✔
77	self._validate_key(key)	3✔
78	return self.deserialize(key, self._store_backend.get(self.key_to_tuple(key)))	3✔
79
80	def set(self, key, value):	3✔
81	self._validate_key(key)	3✔
82	return self._store_backend.set(self.key_to_tuple(key), self.serialize(key, value))	3✔
83
84	def list_keys(self):	3✔
85	return [self.tuple_to_key(key) for key in self._store_backend.list_keys()]	3✔
86
87	def has_key(self, key):	3✔
88	return self._store_backend.has_key(key.to_tuple())	3✔

great-expectations / great_expectations / 4960

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