def test_take_any(self):
r = RangeTree(min=0, max=10)
data = [r.take_any() for i in range(10)]
self.assertEqual(data, list(range(10)))
with self.assertRaises(IndexError):
r.take_any()
def test_bboxQuery_largedata(self):
points = [Point(x, y, 1) for x, y in combinations(range(-200, 200), 2)]
correct = list(filter(lambda f: f[0] >= -10 and f[0] <= 10 and f[1] >= -10 and f[1] <= 10, points))
tree = RangeTree()
tree.create(points)
bbox = BBox(-10, -10, 10, 10)
result = tree.bboxQuery(bbox)
self.assertEqual(len(result), len(correct))
self.assertEqual(set(correct), set(result))
def build_token_list(self, word_freqs):
begin, end = 0, 0
word_idxs = RangeTree()
tokens = RangeTree()
for word, freq in word_freqs:
end += freq
word_idxs[begin:end] = torch.LongTensor(self.get_word_idx(word))
tokens[begin:end] = word
begin = end
return word_idxs, tokens, end
def test_bboxQuery_miss(self):
points = [
Point(-2, 1, 1),
Point(-1, 0, 1),
Point(-2, 0, 1),
Point(-2, 0, 1),
Point(0, 0, 1),
Point(1, 0, 1),
Point(3, 3, 1),
]
tree = RangeTree()
tree.create(points)
bbox = BBox(5, 5, 7, 7)
result = tree.bboxQuery(bbox)
self.assertEqual(result, [])
def map_ip_to_country(self,main_data,additional_data):
self.logger_object.log(self.file_object,'Entered to Map Ip Address to Corresponding Country')
main_data = main_data
add_data = additional_data
try:
main_data['IP_Address'] = main_data['ip_address'].apply(lambda x:math.floor(x))
add_data['Lower_IP'] = add_data['lower_bound_ip_address'].apply(lambda x:math.floor(x))
add_data['Upper_IP'] = add_data['upper_bound_ip_address'].apply(lambda x:math.floor(x))
rt = RangeTree()
for lower,upper,country in zip(add_data['Lower_IP'],add_data['Upper_IP'],add_data['country']):
rt[lower:upper] = country
countries = []
current_tym = datetime.now()
for ip in main_data['IP_Address']:
try:
countries.append(rt[ip])
except:
countries.append('No Country Found')
execution_tym = datetime.now() - current_tym
main_data['Country'] = countries
self.logger_object.log(self.file_object,'Mapping of IP Address to Corresponding Country Successfull in %s' % execution_tym)
return main_data
except Exception as e:
self.logger_object.log(self.file_object,'Error occured while mapping IP Address to Corresponding Country :: %s' % str(e))
raise e
def test_take_all(self):
r = RangeTree(min=0, max=255)
self.assertEqual(r.is_empty(), True)
for i in range(255):
self.assertEqual(i, r.take_any())
self.assertEqual(r.is_empty(), False)
for i in range(255):
r.release(i)
def assertRandomItems(self, *, total, take_factor, seed):
import random
ls = list(range(total))
rng = random.Random(seed)
rng.shuffle(ls)
ls_all = ls[:]
del ls[int(total * take_factor):]
r = RangeTree(min=0, max=total - 1)
for pass_nr in range(4):
self.assertEqual(r.is_empty(), True)
if pass_nr == 0:
pass
elif pass_nr == 1:
ls.reverse()
elif pass_nr == 2:
ls.sort()
elif pass_nr == 3:
ls.reverse()
for i in ls:
r.take(i)
items_a = set(ls)
items_b = set(range(1, total + 1)) - items_a
for i in sorted(items_a):
self.assertEqual(r.has(i), True)
for i in sorted(items_b):
self.assertEqual(r.has(i), False)
# test retake
for i in ls_all:
test = r.retake(i)
self.assertEqual(test, i not in ls)
for i in ls_all:
r.release(i)
def test_bboxQuery_simple(self):
points = [
Point(-2, 1, 1),
Point(-1, 0, 1),
Point(-2, 0, 1),
Point(0, 0, 1),
Point(1, 0, 1),
Point(3, 3, 1),
]
correct = [
Point(-2, 1, 1),
Point(-1, 0, 1),
Point(-2, 0, 1),
]
tree = RangeTree()
tree.create(points)
bbox = BBox(-2.5, -2, -0.5, 2)
result = tree.bboxQuery(bbox)
self.assertEqual(len(result), len(correct))
self.assertEqual(set(result), set(correct))
def test_copy_10(self):
r_src = RangeTree(min=0, max=10)
for i in range(0, 10, 2):
r_src.take(i)
r_dst = r_src.copy()
data = list(r_src.range_iter())
self.assertEqual(data, list(r_dst.range_iter()))
r_dst.clear()
self.assertEqual([], list(r_dst.range_iter()))
def test_simple(self):
r = RangeTree(min=0, max=9)
ls = list(range(0, 10))
for i in ls:
r.take(i)
self.assertEqual(list(r.range_iter()), [(ls[0], ls[-1])])
self.assertEqual(r.has(ls[0] - 0), True)
self.assertEqual(r.has(ls[0] - 1), False)
self.assertEqual(r.has(ls[-1] + 0), True)
self.assertEqual(r.has(ls[-1] + 1), False)
def test_complex(self):
"""
Test complex pairs
"""
r = RangeTree(min=-10, max=11)
# 2 passes on the same data structure.
for _ in range(2):
self.assertEqual(r.is_empty(), True)
for i in (-10, 10, 11):
r.take(i)
self.assertEqual(r.is_empty(), False)
self.assertEqual(list(r.range_iter()), [(-10, -10), (10, 11)])
for i in (-8, -7, 8):
r.take(i)
self.assertEqual(list(r.range_iter()), [(-10, -10), (-8, -7),
(8, 8), (10, 11)])
for i in (-9, 9):
r.take(i)
self.assertEqual(list(r.range_iter()), [(-10, -7), (8, 11)])
for i in (-9, 9):
r.release(i)
self.assertEqual(list(r.range_iter()), [(-10, -10), (-8, -7),
(8, 8), (10, 11)])
for i in (8, 10, 11):
r.release(i)
self.assertEqual(list(r.range_iter()), [(-10, -10), (-8, -7)])
for i in (-10, -8, -7):
r.release(i)
# empty for next pass
self.assertEqual(list(r.range_iter()), [])
from rangetree import RangeTree, BBox, Point, readPointFile, GeometryException
from flask import Flask, jsonify, make_response, request, render_template
import os
app = Flask(__name__)
app.config.update(dict(SECRET_KEY='development key'))
points = readPointFile(
os.path.join(os.path.dirname(__file__), 'data/ipv6data.csv'))
tree = RangeTree()
tree.create(points)
@app.route('/ipv6/api/v1.0/locations', methods=['GET'])
def get_points():
try:
args = request.args.to_dict()
bbox = BBox(float(args['lowerx']), float(args['lowery']),
float(args['upperx']), float(args['uppery']))
except GeometryException:
return make_response('Geometry Exception: invalid bounding box', 400)
except TypeError:
return make_response(
'Invalid inputs. Please use float args for lowerx, lowery, upperx, uppery',
400)
return jsonify([p.heatPoint() for p in tree.bboxQuery(bbox)])
@app.route('/ipv6/')
def index():
def __init__(self):
super().__init__()
self.rt = RangeTree()
self.oracle = defaultdict(list)
self.inf_plus = []
self.inf_minus = []
class RangeTreeStateful(RuleBasedStateMachine):
def __init__(self):
super().__init__()
self.rt = RangeTree()
self.oracle = defaultdict(list)
self.inf_plus = []
self.inf_minus = []
@rule(r=inf_ranges, val=integers())
def add_open_interval(self, r, val):
anchor, direction = r
try:
if direction == '+':
self.rt[anchor:] = val
self.inf_plus.append(anchor)
else:
self.rt[:anchor] = val
self.inf_minus.append(anchor - 1)
except Exception:
pass
@rule(r=all_ranges,
val=integers(),
type_=sampled_from(['slice', 'range']))
def add_interval(self, r, val, type_):
"""Add a range or slice to a rangetree."""
try:
if type_ == 'slice':
self.rt[r[0]:r[1]] = val
else:
self.rt[range(*r)] = val
except KeyError:
pass
else:
for i in range(min(*r), max(*r)):
self.oracle[i].append(val)
@rule(r=all_ranges,
val=integers(),
type_=sampled_from(['slice', 'range']),
step=integers())
def add_interval_step(self, r, val, type_, step):
"""Add a range or slice with a non-default step to a rangetree."""
assume(step != 1)
with pytest.raises(ValueError):
if type_ == 'slice':
self.rt[r[0]:r[1]:step] = val
else:
self.rt[range(*r, step)] = val
@rule()
@precondition(lambda self: self.inf_plus or self.inf_minus)
def assert_open_intervals(self):
assert len(self.inf_plus) <= 1
assert len(self.inf_minus) <= 1
if self.inf_plus and self.inf_minus:
assert self.inf_plus[0] > self.inf_minus[0]
@rule(key=one_of(text(), integers()))
def assert_only_slices_and_ranges(self, key):
with pytest.raises(ValueError):
self.rt[key] = 1
@rule(key=integers())
def assert_missing(self, key):
assume(key not in self.oracle)
assume(not self.inf_plus or self.inf_plus[0] > key)
assume(not self.inf_minus or self.inf_minus[0] < key)
with pytest.raises(KeyError):
self.rt[key]
assert self.rt.get(key) is None
o = object()
assert self.rt.get(key, o) is o
assert key not in self.rt
@rule()
def assert_no_overlap(self):
for k, v in self.oracle.items():
assert len(v) == 1, "Overlap at {}".format(k)
@rule()
def assert_matches_oracle(self):
for k, v in self.oracle.items():
assert k in self.rt
assert self.rt[k] == v[0]
assert self.rt.get(k) == v[0]
@rule(data=data())
@precondition(lambda self: self.inf_plus and not self.oracle)
def assert_open_overlap_plus_contains(self, data):
anchor = self.inf_plus[0]
value_in = data.draw(integers(min_value=anchor))
assert value_in in self.rt
assert self.rt[value_in] is not None
assert self.rt.get(value_in) == self.rt[value_in]
if self.inf_minus:
anchor_minus = self.inf_minus[0]
if anchor_minus + 1 == anchor:
return
value_out = data.draw(
integers(min_value=anchor_minus + 1, max_value=anchor - 1))
else:
value_out = data.draw(integers(max_value=anchor - 1))
assert value_out not in self.rt
with pytest.raises(KeyError):
self.rt[value_out]
assert self.rt.get(value_out, -1) == -1
@rule(data=data())
@precondition(lambda self: self.inf_minus and not self.oracle)
def assert_open_overlap_minus_contains(self, data):
anchor = self.inf_minus[0]
value_in = data.draw(integers(max_value=anchor))
assert value_in in self.rt
assert self.rt[value_in] is not None
assert self.rt.get(value_in) == self.rt[value_in]
if self.inf_plus:
anchor_plus = self.inf_plus[0]
if anchor + 1 == anchor_plus:
return
value_out = data.draw(
integers(min_value=anchor + 1, max_value=anchor_plus - 1))
else:
value_out = data.draw(integers(min_value=anchor + 1))
assert value_out not in self.rt
with pytest.raises(KeyError):
self.rt[value_out]
assert self.rt.get(value_out, -1) == -1
def test_copy_empty(self):
r_src = RangeTree(min=0, max=10)
r_dst = r_src.copy()
self.assertEqual(list(r_src.range_iter()), list(r_dst.range_iter()))
def assertRangeData(self, range_iter):
range_ls_src = list(range_iter)
r = RangeTree.FromRanges(range_ls_src)
range_ls_dst = list(r.range_iter())
range_ls_src.sort()
self.assertEqual(range_ls_src, range_ls_dst)
def test_create_null(self):
points = []
tree = RangeTree()
tree.create(points)
self.assertEqual(len(points), len(tree.traverse()))
self.assertEqual(set(points), set(tree.traverse()))
def test_many(self):
r = RangeTree(min=0, max=9)
# 2 passes to be sure
for _ in range(2):
self.assertEqual(r.is_empty(), True)
ls = list(range(0, 10, 2))
for i in ls:
r.take(i)
self.assertEqual(r.is_empty(), False)
self.assertEqual(r.has(ls[0] - 0), True)
self.assertEqual(r.has(ls[0] - 1), False)
self.assertEqual(r.has(ls[-1] + 0), True)
self.assertEqual(r.has(ls[-1] + 1), False)
self.assertEqual(
list(r.range_iter()),
[(0, 0), (2, 2), (4, 4), (6, 6), (8, 8)],
)
r.release(ls.pop(0))
r.release(ls.pop(-1))
r.take(3)
r.take(5)
self.assertEqual(list(r.range_iter()), [(2, 6)])
r.release(2)
r.release(6)
self.assertEqual(list(r.range_iter()), [(3, 5)])
r.release(4)
self.assertEqual(list(r.range_iter()), [(3, 3), (5, 5)])
for i in (3, 5):
r.release(i)
self.assertEqual(list(r.range_iter()), [])
def test_create(self):
points = [Point(x, y, 1) for x, y in combinations(range(-10, 10), 2)]
tree = RangeTree()
tree.create(points)
self.assertEqual(len(points), len(tree.traverse()))
self.assertEqual(set(points), set(tree.traverse()))
