def _parse_datetime(dct):
FORMAT_24H = ('%H:%M:%S', '%H:%M')
FORMAT_12H = ('%I:%M:%S%p', '%I:%M%p', '%I:%M:%S %p', '%I:%M %p', '%I%p', '%I %p')
def get_time(time_str):
if Str.contains_any(time_str, 'am', 'pm', 'a.m.', 'p.m.'):
return Dt.get_time(time_str, FORMAT_12H, default_value=False)
elif ':' in time_str:
return Dt.get_time(time_str, FORMAT_24H, default_value=False)
return False
def fuzzy_is_datetime(dt):
# 2014
year = re.match(r'\d{4}', dt)
# 10:30pm
time = re.match(r'\d?\d\d', dt)
return bool(year or time)
for k, v in dct.items():
if isinstance(v, str) and not Str.is_int(v):
try:
time_value = get_time(v)
if time_value is not False:
dct[k] = time_value
elif fuzzy_is_datetime(v):
dct[k] = parser.parse(v)
except:
pass
return dct
def as_table(data, filter_param=None):
"""
Turn queryset or list row_dict into a table.
:param data: queryset|list of [row_dict]
:param filter_param: comma separated list of column. Syntax: queryset|as_table:'include_me, !not_include, include2'
eg. users|as_table:'!age, !password'
eg. group|as_table:'name, group_count'
:return:
"""
if not data:
return None
result = []
filter_list = []
exclude_list = []
model = Obj.getattr(data, 'model', None, False)
if filter_param:
filter_param_list = Lst.strip_string(filter_param.split(','))
for the_filter in filter_param_list:
assert isinstance(the_filter, str)
if the_filter.startswith('!'):
exclude_list.append(the_filter[1:])
else:
filter_list.append(the_filter)
if isinstance(data, dict):
sub_tables = {}
for key, row in data.items():
if isinstance(row, list):
sub_tables[key] = as_table(row, filter_param)
continue
row_dict = Obj.get_dict(row, filter_list, exclude_list, verbose_key=True, get_display=True)
result.append(row_dict)
if sub_tables:
context = {'sub_tables': sub_tables}
html = render_to_string('lazifier/table_filter/as_table_filter_sub_tables_layout.html', context)
return mark_safe(html)
else:
if isinstance(data, collections.Iterable):
for row in data:
row_dict = Obj.get_dict(row, filter_list, exclude_list, verbose_key=True, get_display=True)
for k, v in row_dict.items():
if isinstance(v, list):
if v:
row_dict[k] = as_table(v, filter_param)
result.append(row_dict)
else:
result.append(Obj.get_dict(data, verbose_key=True))
if result:
headers = []
if model is not None:
columns = result[0].keys()
headers = list(Mdl.get_field_verbose(model, columns).values())
else:
for k, v in result[0].items():
if Str.is_int(k):
headers.append(type(v).__name__)
elif type(k) is str and k.islower():
headers.append(Str.snake_to_title(k))
else:
headers.append(k)
context = {'headers': headers, 'data': result}
html = render_to_string('lazifier/table_filter/as_table_filter_layout.html', context)
else:
return None
return mark_safe(html)
self.assertTrue(Str.contains("Hello", "hell"))
self.assertFalse(Str.contains("Hello", "hell", case=True))
# base64
plain_str = 'hello world!'
b64 = 'aGVsbG8gd29ybGQh'
self.assertEqual(Str.base64_encode(plain_str), b64)
self.assertEqual(Str.base64_decode(b64), plain_str)
plain_str = 'this is a test'
b64 = 'dGhpcyBpcyBhIHRlc3Q='
self.assertEqual(Str.base64_encode(plain_str), b64)
self.assertEqual(Str.base64_decode(b64), plain_str)
# is_int()
self.assertTrue(Str.is_int('0'))
self.assertTrue(Str.is_int('1'))
self.assertTrue(Str.is_int('-1'))
self.assertFalse(Str.is_int('1.0'))
self.assertFalse(Str.is_int('-1.0'))
self.assertFalse(Str.is_int('-0'))
self.assertFalse(Str.is_int('- 70'))
class ObjTest(SimpleTestCase):
def test_get_attr(self):
not_found = 'Not Found!'
class Test:
def __init__(self, a, b, other_test=None):
self.a = a