def test_extent_all(self):
a = segments.segmentlistdict({
"H1":
segments.segmentlist(),
"L1":
segments.segmentlist([segments.segment(25, 35)])
})
assert a.extent_all() == segments.segment(25, 35)
def test_pickle(self):
a = segments.segmentlistdict({
"H1":
segments.segmentlist(
[segments.segment(0, 10),
segments.segment(20, 30)])
})
a.offsets["H1"] = 10.0
assert a == pickle.loads(pickle.dumps(a, protocol=0))
assert a == pickle.loads(pickle.dumps(a, protocol=1))
assert a == pickle.loads(pickle.dumps(a, protocol=2))
def test_contract(self):
assert segments.segmentlist([segments.segment(0, 20)
]) == (segments.segmentlist([
segments.segment(3, 7),
segments.segment(13, 17)
]).contract(-3))
# confirm that .contract() preserves the type of the
# segment objects
class MyCustomSegment(segments.segment):
pass
class MyCustomSegmentList(segments.segmentlist):
def coalesce(self):
# must override for test, but don't have to
# implement because test case is too simple
return self
assert type(
MyCustomSegmentList([MyCustomSegment(0, 10)
]).contract(1)[0]) is MyCustomSegment
def test_intersects(self):
a = segments.segmentlistdict({
"H1":
segments.segmentlist(
[segments.segment(0, 10),
segments.segment(20, 30)])
})
b = segments.segmentlistdict({
"H1":
segments.segmentlist([segments.segment(5, 15)]),
"L1":
segments.segmentlist([segments.segment(25, 35)])
})
c = segments.segmentlistdict({
"V1":
segments.segmentlist(
[segments.segment(7, 13),
segments.segment(27, 40)])
})
assert a.intersects(b)
assert b.intersects(a)
assert a.intersects(a)
assert not a.intersects(c)
assert not b.intersects(segments.segmentlistdict({}))
assert not segments.segmentlistdict({}).intersects(
segments.segmentlistdict({}))
assert not a.intersects_all(b)
assert b.intersects_all(a)
assert a.all_intersects(b)
assert not b.all_intersects(a)
assert not a.all_intersects_all(b)
def test_coalesce(self):
# check that mixed-type coalescing works
x = segments.segmentlist(
[segments.segment(1, 2),
segments.segment(3, 4), (2, 3)])
try:
assert x.coalesce() == segments.segmentlist(
[segments.segment(1, 4)])
except AssertionError as e:
raise AssertionError("mixed type coalesce failed: got %s" %
str(x))
# try a bunch of random segment lists
for i in range(algebra_repeats):
a = verifyutils.random_uncoalesced_list(
random.randint(1, algebra_listlength))
b = segments.segmentlist(a[:]).coalesce()
assert verifyutils.iscoalesced(b)
for seg in a:
assert seg in b
for seg in a:
b -= segments.segmentlist([seg])
assert b == segments.segmentlist([])
def test_new(self):
assert (-2, 2) == tuple(segments.segment(-2, 2))
assert (-2, 2) == tuple(segments.segment(2, -2))
assert (-segments.infinity(),
2) == tuple(segments.segment(-segments.infinity(), 2))
assert (-segments.infinity(),
2) == tuple(segments.segment(2, -segments.infinity()))
assert (2, segments.infinity()) == tuple(
segments.segment(segments.infinity(), 2))
assert (2, segments.infinity()) == tuple(
segments.segment(2, segments.infinity()))
assert (-segments.infinity(), segments.infinity()) == tuple(
segments.segment(-segments.infinity(), segments.infinity()))
def test_typesafety(self):
w = "segments.segmentlist([segments.segment(0, 10), segments.segment(20, 30)])"
x = "segments.segment(10, 20)"
y = "[(10, 20)]"
z = "None"
for op in ("|", "&", "-", "^"):
for arg1, arg2 in ((w, x), (x, w), (w, z), (z, w)):
expr = "%s %s %s" % (arg1, op, arg2)
try:
eval(expr)
except TypeError:
pass
else:
raise AssertionError("%s did not raise TypeError" % expr)
assert eval("%s | %s" % (w, y)) == segments.segmentlist(
[segments.segment(0, 30)])
def draw_form(form_type, f, method, dynamic_options={}):
form_content = ""
required_fields = []
groups = get_form_groups(form_type)
if not groups or len(groups) == 0:
fields = {}
if form_type == "lists":
import lists
fields = lists.fields()
elif form_type == "templates":
import templates
fields = templates.template()
elif form_type == "template_categories":
import templates
fields = templates.template_category()
elif form_type == 'emails':
import emails
fields = emails.email()
elif form_type == 'segments':
import segments
fields = segments.segment()
elif form_type == 'campaigns':
import campaigns
fields = campaigns.campaign()
elif form_type == "ab_tests":
import campaigns
fields = campaigns.variate_campaign()
if len(fields) > 0:
init_form(fields, form_type)
groups = get_form_groups(form_type)
for group in groups:
if method == "new":
fields = group.fields.filter(FormField.create == True).order_by(FormField.rank.asc()).all()
elif method == "update":
fields = group.fields.filter(FormField.update == True).order_by(FormField.rank.asc()).all()
else:
return ""
if len(fields) > 0:
if group.fieldset_on_form:
form_content = """%s
<fieldset id="%s">
<legend>%s</legend>""" % (form_content, group.id, group.name)
for field in group.fields:
#print field.rank
field_value = ""
alt_field_name = '%s_%s' % (form_type, field.name)
if field.name in f:
field_value = f[field.name]
elif alt_field_name in f:
field_value = f[alt_field_name]
elif field.default_value != None:
field_value = field.default_value
input_field = ""
required = ""
field_name = '%s_%s' % (form_type, field.name)
if field.required:
required = "required"
required_fields.append(field_name)
if field.tag == "input":
classes = ""
maxlength = ""
if field.field_type == "checkbox":
classes = " sw-checkbox"
if field_value != False:
maxlength = " checked "
field_value == "1"
else:
field_value == "0"
elif field.field_type == "text":
maxlength = " maxlength='%s' " % field.max_length
input_field = '<input type="%s" name="%s" id="%s" class="form-control %s" value="%s" %s %s />' % (field.field_type, field_name, field_name, classes, field_value, maxlength, required)
elif field.tag == "textarea":
input_field = '<textarea name="%s" id="%s" class="form-control" style="height:100px;" %s>%s</textarea' % (field_name, field_name, field_value, required)
elif field.tag == "select":
input_field = '<select name="%s" id="%s" class="form-control" %s>' % (field_name, field_name, required)
if field.options.count() > 0:
for option in field.options.order_by(FormFieldOption.label.asc()).all():
selected = ""
if (option.value == field_value) or (field_value == "None" and option.value == '0'):
selected = " selected"
input_field = '%s<option value="%s" %s>%s</option>' % (input_field, option.value, selected, option.label)
elif field_name in dynamic_options:
#print dynamic_options
sorted_options = sorted(dynamic_options[field_name].items(), key=(operator.itemgetter(0)))
for value, label in sorted_options:
selected = ""
if (str(value) == str(field_value)) or (field_value == "None" and str(value) == '0'):
selected = ' selected="selected"'
input_field = '%s<option value="%s" %s>%s</option>' % (input_field, value, selected, label)
input_field = '%s\n</select>' % input_field
if input_field != "":
form_content = """%s
<div class="form-group">
<label for="%s" class="control-label col-lg-2">%s</label>
<div class="col-lg-10">
%s
</div>
</div>""" % (form_content, field.name, field.label, input_field)
if group.fieldset_on_form:
form_content = '%s</fieldset>' % form_content
return form_content, required_fields
def set2():
return (segments.segment(-4, -3), segments.segment(-4, -2),
segments.segment(-4, 0), segments.segment(-4, 2),
segments.segment(-4, 4), segments.segment(-2, 4),
segments.segment(0, 4), segments.segment(2, 4),
segments.segment(3,
4), segments.segment(-2,
2), segments.segment(-1, 1),
segments.segment(-segments.infinity(), segments.infinity()),
segments.segment(0, segments.infinity()),
segments.segment(-segments.infinity(), 0))
def test_extent(self):
assert segments.segmentlist([(1, 0)
]).extent() == (segments.segment(0, 1))
def set1():
return (segments.segment(-2, 2), segments.segment(-2, 2),
segments.segment(-2, 2), segments.segment(-2, 2),
segments.segment(-2, 2), segments.segment(-2, 2),
segments.segment(-2, 2), segments.segment(-2, 2),
segments.segment(-2, 2), segments.segment(-2, 2),
segments.segment(-2, 2), segments.segment(-2, 2),
segments.segment(-2, 2), segments.segment(-2, 2))
class TestSegmentlist(object):
@pytest.mark.parametrize(
'a, b',
[
(segments.segmentlist(
[]), segments.segmentlist([]) - segments.segmentlist([])),
(segments.segmentlist([]), segments.segmentlist([]) -
segments.segmentlist([segments.segment(-1, 1)])),
(segments.segmentlist([segments.segment(-1, 1)]) -
segments.segmentlist([segments.segment(-1, 1)]),
segments.segmentlist([])),
(segments.segmentlist(
[]), segments.segmentlist([segments.segment(-1, 1)]) -
segments.segmentlist([segments.segment(-1, 1)])),
#(segments.segmentlist([]),
# segments.segmentlist([segments.segment(0,0)]) -
# segments.segmentlist([segments.segment(0,0)])),
(segments.segmentlist([segments.segment(
0, 1)]), segments.segmentlist([segments.segment(0, 1)]) -
segments.segmentlist([segments.segment(2, 3)])),
(segments.segmentlist([segments.segment(
0, 1)]), segments.segmentlist([segments.segment(0, 1)]) -
segments.segmentlist(
[segments.segment(2, 3),
segments.segment(4, 5)])),
(segments.segmentlist([segments.segment(0, 1)]),
segments.segmentlist(
[segments.segment(0, 1),
segments.segment(2, 3)]) -
segments.segmentlist([segments.segment(2, 3)])),
(segments.segmentlist([segments.segment(2, 3)]),
segments.segmentlist(
[segments.segment(0, 1),
segments.segment(2, 3)]) -
segments.segmentlist([segments.segment(0, 1)])),
(segments.segmentlist(
[segments.segment(0, 1),
segments.segment(4, 5)]),
segments.segmentlist([
segments.segment(0, 1),
segments.segment(2, 3),
segments.segment(4, 5)
]) - segments.segmentlist([segments.segment(2, 3)])),
(segments.segmentlist([segments.segment(
0, 1)]), segments.segmentlist([segments.segment(0, 2)]) -
segments.segmentlist([segments.segment(1, 2)])),
(segments.segmentlist([
segments.segment(0.8, 0.9),
segments.segment(1.0, 1.8)
]), segments.segmentlist([segments.segment(0, 2)]) -
segments.segmentlist([
segments.segment(0, 0.8),
segments.segment(0.9, 1.0),
segments.segment(1.8, 2)
])),
(segments.segmentlist([segments.segment(
-5, 10)]), segments.segmentlist([segments.segment(-10, 10)]) -
segments.segmentlist([segments.segment(-15, -5)])),
(segments.segmentlist([
segments.segment(-10, -5),
segments.segment(5, 10)
]), segments.segmentlist([segments.segment(-10, 10)]) -
segments.segmentlist([segments.segment(-5, 5)])),
(segments.segmentlist([segments.segment(
-10, 5)]), segments.segmentlist([segments.segment(-10, 10)]) -
segments.segmentlist([segments.segment(5, 15)])),
(segments.segmentlist(
[segments.segment(0, 5),
segments.segment(45, 50)]),
segments.segmentlist([
segments.segment(0, 10),
segments.segment(20, 30),
segments.segment(40, 50)
]) - segments.segmentlist([segments.segment(5, 45)])),
])
def test_sub(self, a, b):
assert a == b
@pytest.mark.parametrize('a, b', [
(segments.segmentlist([
segments.segment(-segments.infinity(), segments.infinity())
]), segments.segmentlist([])),
(segments.segmentlist([]),
segments.segmentlist(
[segments.segment(-segments.infinity(), segments.infinity())])),
(segments.segmentlist([
segments.segment(-segments.infinity(), -5),
segments.segment(5, segments.infinity())
]), segments.segmentlist([segments.segment(-5, 5)])),
])
def test_invert(self, a, b):
assert a == ~b
def test_and(self):
for i in range(algebra_repeats):
a = verifyutils.random_coalesced_list(
random.randint(1, algebra_listlength))
b = verifyutils.random_coalesced_list(
random.randint(1, algebra_listlength))
c = a & b
assert c == a - (a - b)
assert c == b - (b - a)
def test_or(self):
for i in range(algebra_repeats):
a = verifyutils.random_coalesced_list(
random.randint(1, algebra_listlength))
b = verifyutils.random_coalesced_list(
random.randint(1, algebra_listlength))
c = a | b
# make sure c is coalesced
assert verifyutils.iscoalesced(c)
# make sure c contains all of a
assert a == c & a
# make sure c contains all of b
assert b == c & b
# make sure c contains nothing except a and b
assert segments.segmentlist([]) == c - a - b
def test_xor(self):
for i in range(algebra_repeats):
a = verifyutils.random_coalesced_list(
random.randint(1, algebra_listlength))
b = verifyutils.random_coalesced_list(
random.randint(1, algebra_listlength))
c = a ^ b
# c contains nothing that can be found in
# the intersection of a and b
assert not c.intersects(a & b)
# c contains nothing that cannot be found
# in either a or b
assert segments.segmentlist([]) == c - a - b
# that c + the intersection of a and b
# leaves no part of either a or b
# unconvered
assert segments.segmentlist([]) == a - (c | a & b)
assert segments.segmentlist([]) == b - (c | a & b)
def test_protract(self):
assert segments.segmentlist([segments.segment(0, 20)
]) == (segments.segmentlist([
segments.segment(3, 7),
segments.segment(13, 17)
]).protract(3))
# confirm that .protract() preserves the type of the
# segment objects
class MyCustomSegment(segments.segment):
pass
class MyCustomSegmentList(segments.segmentlist):
def coalesce(self):
# must override for test, but don't have to
# implement because test case is too simple
return self
assert type(
MyCustomSegmentList([MyCustomSegment(0, 10)
]).protract(1)[0]) is MyCustomSegment
def test_contract(self):
assert segments.segmentlist([segments.segment(0, 20)
]) == (segments.segmentlist([
segments.segment(3, 7),
segments.segment(13, 17)
]).contract(-3))
# confirm that .contract() preserves the type of the
# segment objects
class MyCustomSegment(segments.segment):
pass
class MyCustomSegmentList(segments.segmentlist):
def coalesce(self):
# must override for test, but don't have to
# implement because test case is too simple
return self
assert type(
MyCustomSegmentList([MyCustomSegment(0, 10)
]).contract(1)[0]) is MyCustomSegment
def test_intersects(self):
for i in range(algebra_repeats):
a = verifyutils.random_coalesced_list(
random.randint(1, algebra_listlength))
b = verifyutils.random_coalesced_list(
random.randint(1, algebra_listlength))
c = a - b
d = a & b
if len(c):
assert not c.intersects(b)
if len(d):
assert d.intersects(a)
assert d.intersects(b)
assert a.intersects(b)
def test_extent(self):
assert segments.segmentlist([(1, 0)
]).extent() == (segments.segment(0, 1))
def test_coalesce(self):
# check that mixed-type coalescing works
x = segments.segmentlist(
[segments.segment(1, 2),
segments.segment(3, 4), (2, 3)])
try:
assert x.coalesce() == segments.segmentlist(
[segments.segment(1, 4)])
except AssertionError as e:
raise AssertionError("mixed type coalesce failed: got %s" %
str(x))
# try a bunch of random segment lists
for i in range(algebra_repeats):
a = verifyutils.random_uncoalesced_list(
random.randint(1, algebra_listlength))
b = segments.segmentlist(a[:]).coalesce()
assert verifyutils.iscoalesced(b)
for seg in a:
assert seg in b
for seg in a:
b -= segments.segmentlist([seg])
assert b == segments.segmentlist([])
def test_typesafety(self):
w = "segments.segmentlist([segments.segment(0, 10), segments.segment(20, 30)])"
x = "segments.segment(10, 20)"
y = "[(10, 20)]"
z = "None"
for op in ("|", "&", "-", "^"):
for arg1, arg2 in ((w, x), (x, w), (w, z), (z, w)):
expr = "%s %s %s" % (arg1, op, arg2)
try:
eval(expr)
except TypeError:
pass
else:
raise AssertionError("%s did not raise TypeError" % expr)
assert eval("%s | %s" % (w, y)) == segments.segmentlist(
[segments.segment(0, 30)])
def test_contains_2(self):
assert [1, 2] in segments.segment(0, 4)
assert [1, 6] not in segments.segment(0, 4)
assert [-1, 2] not in segments.segment(0, 4)
assert [-1, 6] not in segments.segment(0, 4)
assert 2 in segments.segment(0, 4)
# Paraphrasing the documentation for glue.segment.__contains__
# in segments/segments.py: if a is a segment or a sequence of length two,
# then `a in b` tests if `b[0] <= a[0] <= a[1] <= b[1]`. Otherwise,
# `a in b` tests if `b[0] <= a <= b[1]`. The following four tests
# happen to work and return False in Python 2, but they raise
# a TypeError in Python 3 because Python does not permit comparisons
# of numbers with sequences. The exception message is
# "'<' not supported between instances of 'list' and 'int'".
if sys.version_info.major <= 2:
assert [] not in segments.segment(0, 4)
assert [0] not in segments.segment(0, 4)
assert [2] not in segments.segment(0, 4)
assert [1, 2, 3] not in segments.segment(0, 4)
else:
with pytest.raises(TypeError):
assert [] not in segments.segment(0, 4)
with pytest.raises(TypeError):
assert [0] not in segments.segment(0, 4)
with pytest.raises(TypeError):
assert [2] not in segments.segment(0, 4)
with pytest.raises(TypeError):
assert [1, 2, 3] not in segments.segment(0, 4)
class TestSegment(object):
def test_new(self):
assert (-2, 2) == tuple(segments.segment(-2, 2))
assert (-2, 2) == tuple(segments.segment(2, -2))
assert (-segments.infinity(),
2) == tuple(segments.segment(-segments.infinity(), 2))
assert (-segments.infinity(),
2) == tuple(segments.segment(2, -segments.infinity()))
assert (2, segments.infinity()) == tuple(
segments.segment(segments.infinity(), 2))
assert (2, segments.infinity()) == tuple(
segments.segment(2, segments.infinity()))
assert (-segments.infinity(), segments.infinity()) == tuple(
segments.segment(-segments.infinity(), segments.infinity()))
@pytest.mark.parametrize('a, result',
zip(set2(), [
1, 2, 4, 6, 8, 6, 4, 2, 1, 4, 2,
segments.infinity(),
segments.infinity(),
segments.infinity()
]))
def test_abs(self, a, result):
assert abs(a) == result
@pytest.mark.parametrize('a, b, result',
zip(set1(), set2(), [
False, False, True, True, True, True, True,
False, False, True, True, True, True, True
]))
def test_intersects(self, a, b, result):
assert a.intersects(b) == result
@pytest.mark.parametrize(
'a, b, result',
zip(set1(), set2(), [
False, False, False, False, False, False, False, False, False,
True, True, False, False, False
]))
def test_contains_1(self, a, b, result):
assert (b in a) == result
def test_contains_2(self):
assert [1, 2] in segments.segment(0, 4)
assert [1, 6] not in segments.segment(0, 4)
assert [-1, 2] not in segments.segment(0, 4)
assert [-1, 6] not in segments.segment(0, 4)
assert 2 in segments.segment(0, 4)
# Paraphrasing the documentation for glue.segment.__contains__
# in segments/segments.py: if a is a segment or a sequence of length two,
# then `a in b` tests if `b[0] <= a[0] <= a[1] <= b[1]`. Otherwise,
# `a in b` tests if `b[0] <= a <= b[1]`. The following four tests
# happen to work and return False in Python 2, but they raise
# a TypeError in Python 3 because Python does not permit comparisons
# of numbers with sequences. The exception message is
# "'<' not supported between instances of 'list' and 'int'".
if sys.version_info.major <= 2:
assert [] not in segments.segment(0, 4)
assert [0] not in segments.segment(0, 4)
assert [2] not in segments.segment(0, 4)
assert [1, 2, 3] not in segments.segment(0, 4)
else:
with pytest.raises(TypeError):
assert [] not in segments.segment(0, 4)
with pytest.raises(TypeError):
assert [0] not in segments.segment(0, 4)
with pytest.raises(TypeError):
assert [2] not in segments.segment(0, 4)
with pytest.raises(TypeError):
assert [1, 2, 3] not in segments.segment(0, 4)
@pytest.mark.parametrize('a, b, result',
zip(set1(), set2(), [
+1,
0,
0,
0,
0,
0,
0,
0,
-1,
0,
0,
0,
0,
0,
]))
def test_disjoint(self, a, b, result):
assert a.disjoint(b) == result
@pytest.mark.parametrize(
'a, result',
zip(set2(), [
segments.segment(-5, -2),
segments.segment(-4, -2),
segments.segment(-2, -2),
segments.segment(-2, 0),
segments.segment(-2, 2),
segments.segment(0, 2),
segments.segment(2, 2),
segments.segment(2, 4),
segments.segment(2, 5),
segments.segment(0, 0),
segments.segment(-1, 1),
segments.segment(-segments.infinity(), segments.infinity()),
segments.segment(2, segments.infinity()),
segments.segment(-segments.infinity(), -2),
]))
def test_contract(self, a, result):
assert a.contract(2) == result
def test_typesafety(self):
x = "segments.segment(10, 20)"
y = "(20, 30)"
z = "None"
for op in ("|", "&", "-", "^"):
for arg1, arg2 in ((x, z), (z, x)):
expr = "%s %s %s" % (arg1, op, arg2)
try:
eval(expr)
except TypeError:
pass
else:
raise AssertionError("%s did not raise TypeError" % expr)
data.append([
'Centre Code', 'Roll No', 'Name', 'Category', 'Mobile Number', 'question'
])
#
i = 0
for s in os.listdir(In_path):
print(i)
i = i + 1
ext = os.path.splitext(s)[1]
if ext.lower() not in valid_images:
continue
input_img = os.path.join(In_path, s)
q1, q2, q3, q4, q5, name, mob, roll, center, cat = segments.segment(
input_img)
quest1 = Question_recog.question(q1)
quest2 = Question_recog.question(q2)
quest3 = Question_recog.question(q3)
quest4 = Question_recog.question(q4)
quest5 = Question_recog.question(q5)
quest = quest1 + quest2 + quest3 + quest4 + quest5
name = Name_recog.nameread(name)
mobile = Mobile_recog.mobile(mob)
rollno = Roll_no.roll_no(roll)
code = Center_code.code(center)
cate = Category.category(cat)
data.append([code, rollno, name, cate, mobile, quest])
with open('output.csv', 'w') as writeFile:
def __init__(self, query, **kwargs):
super(HighlighterBase, self).__init__(query, **kwargs)
self.query_words = set(segment(query).split())
