def fetch_data(self, query):
with self.connection.cursor() as cur:
self.logger.debug('Query Execution Started !!!')
cur.execute(query)
cols = [a[0].decode("utf-8") for a in cur.description]
self.logger.debug('RDS Meta Data Column Names: %s' % cols)
records = [{a: b
for a, b in zip(cols, row)} for row in cur.fetchall()]
opt_val = Optional(records)
if not opt_val.is_present():
return Optional.empty()
return opt_val
def test_is_present(self):
opt = Optional.empty()
self.assertFalse(opt.is_present())
opt_actual_values = [Optional(v) for v in [None, '', [], {}]]
for opt in opt_actual_values:
self.assertFalse(opt.is_present())
opt_actual_values = [
Optional(v) for v in ['text', ['some'], {
'key': 'val'
}, 0, 0.0]
]
for opt in opt_actual_values:
self.assertTrue(opt.is_present())
def wrapper(*args, **kwargs):
try:
response = func(*args, **kwargs)
return response
except Exception as e:
msg = '{}\n{}'.format(err_msg, str(e)) if err_msg else str(e)
logger.error('{}'.format(msg))
return Optional.empty()
def getall_hkeys(self,
namespace=None,
key_prefix=None,
key_suffix=None,
key_contains=None) -> Optional:
"""
Returns all keys under hash/ namespace.
Use 'key_prefix', 'key_suffix', 'key_contains' to filter specific keys.
:param namespace:
:param key_prefix:
:param key_suffix:
:param key_contains:
:return:
"""
ns = namespace if namespace else self.namespace
# a non existent namespace or hash returns a empty map, and optional of empty map returns True.
val = self.client.hgetall(ns)
if val:
filter_func = None
if key_prefix:
filter_func = lambda key: key.startswith(key_prefix)
elif key_suffix:
filter_func = lambda key: key.endswith(key_suffix)
elif key_contains:
filter_func = lambda key: key_contains in key
hm = {}
for k, v in val.items():
key, val = k.decode('utf-8'), self.__do_eval(v.decode('utf-8'))
if filter_func:
if filter_func(key):
hm[key] = val
else:
hm[key] = val
return Optional(hm) if len(hm) > 0 else Optional.empty()
return Optional.empty()
def get_hkeys(self, keys: list, namespace=None, eval=True) -> Optional:
"""
To retrieve values of given keys from namespace.
Set eval=False to retrieve the data as is in bytes.
The default behaviour is to convert it into python objects.
:param keys:
:param namespace:
:param eval:
:return: returns a dict key values from redis.
"""
if not isinstance(keys, list):
raise TypeError(f"'keys' should be 'list' type.")
# Join key if key itself a list
keys = list(
map(
lambda key: self.key_delim.join(key)
if isinstance(key, list) else key, keys))
ns = namespace if namespace else self.namespace
opt_val = Optional(self.client.hmget(ns, keys))
if not opt_val.is_present():
return Optional.empty()
keyvals = {}
for idx, value in enumerate(opt_val.get()):
keyvals[keys[idx]] = value
keyvals = dict([(key, value) for key, value in keyvals.items()
if value is not None])
for key, value in keyvals.items():
keyvals[key] = self.__do_eval(
value.decode('utf-8')) if eval else value.decode('utf-8')
return Optional(keyvals)
def get_hkey(self, key, namespace=None, eval=True) -> Optional:
"""
To retrieve a specific Key from namespace.
Set eval=False to retrieve the data as is in bytes.
The default behaviour is to convert it into python objects.
:param key:
:param namespace:
:param eval:
:return:
"""
ns = namespace if namespace else self.namespace
val = None
if isinstance(key, list):
opt_val = Optional(self.client.hget(ns, self.key_delim.join(key)))
else:
opt_val = Optional(self.client.hget(ns, key))
if opt_val.is_present():
val = opt_val.get().decode("utf-8")
if eval:
return Optional(self.__do_eval(val))
return opt_val
def test_get(self):
with self.assertRaises(OptionalNoneValueError):
Optional.empty().get()
opt = Optional('one')
self.assertTrue(opt.is_present())
self.assertEqual('one', opt.get())
fl = 0.001
opt = Optional(fl)
self.assertEqual(fl, opt.get())
l = ['one', 'two']
opt = Optional(l)
self.assertListEqual(l, opt.get())
m = {'one': 1}
opt = Optional(m)
self.assertDictEqual(m, opt.get())
def test_get_or_raise(self):
opt = Optional.empty()
self.assertFalse(opt.is_present())
with self.assertRaises(KeyError):
opt.get_or_raise(KeyError, 'KEY_NOT_FOUND')
def test_get_or_else(self):
opt = Optional.empty()
self.assertFalse(opt.is_present())
self.assertEqual('one', opt.get_or_else('one'))