def test_update_cell_in_cell_datasets(self):
store.dropAll()
bds = BoundaryDataSet("id")
boundaries = [
'O23P12P34S56', 'P10P11P2', 'N0', 'N8O2P0', 'O6S0S1S2', 'Q'
]
for boundary in boundaries:
bds.add(Boundary(boundary_ID=BoundaryID(boundary)), Data(""))
store.insert(bds)
store.update_boundary_in_boundary_datasets(
"id", (Boundary(boundary_ID=BoundaryID('O23P12P34S56'))),
Data("test"))
stored_bds = store.query_by_boundary_in_boundary_datasets(
"id", (Boundary(boundary_ID=BoundaryID('O23P12P34S56'))))
num_bds = 0
num_boundaries = 0
for bds in stored_bds:
for boundary, data in bds.get_boundaries_and_data():
assert boundaries.__contains__(boundary.AUID_to_CUIDs())
assert data.content == Data("test").content
num_boundaries = num_boundaries + 1
num_bds = num_bds + 1
self.assertEqual(num_bds, 1)
self.assertEqual(num_boundaries, 1)
store.dropAll()
def test_delete_boundary_in_boundary_datasets(self):
store.dropAll()
bds = BoundaryDataSet("id")
boundaries = [
'O23P12P34S56', 'P10P11P2', 'N0', 'N8O2P0', 'O6S0S1S2', 'Q'
]
for boundary in boundaries:
bds.add(Boundary(boundary_ID=BoundaryID(boundary)), Data(""))
store.insert(bds)
deleted_boundaries = store.delete_boundary_in_boundary_datasets(
"id", (Boundary(boundary_ID=BoundaryID('O23P12P34S56'))))
self.assertEqual(deleted_boundaries, 1)
stored_bds = store.query_by_boundary_in_boundary_datasets(
"id", (Boundary(boundary_ID=BoundaryID('O23P12P34S56'))))
num_bds = 0
for bds in stored_bds:
assert bds.get_boundaries().__len__() == 0
num_bds = num_bds + 1
assert num_bds == 1
self.assertEqual(num_bds, 1)
store.dropAll()
def test_update_boundary_dataset(self):
store.dropAll()
bds = BoundaryDataSet("id")
boundaries = [
'O23P12P34S56', 'P10P11P2', 'N0', 'N8O2P0', 'O6S0S1S2', 'Q'
]
for boundary in boundaries:
bds.add(Boundary(boundary_ID=BoundaryID(boundary)), Data(""))
store.insert(bds)
bds2 = BoundaryDataSet("id")
boundaries2 = ['N0', 'N8O2P0', 'O6S0S1S2', 'Q']
for boundary in boundaries2:
bds2.add(Boundary(boundary_ID=BoundaryID(boundary)), Data(""))
store.update_boundary_dataset(bds2)
stored_bds = store.query_by_boundary_dataset_id("id")
num_bds = 0
num_boundaries = 0
for bds in stored_bds:
for boundary in bds.get_boundaries():
assert boundaries2.__contains__(boundary.AUID_to_CUIDs())
num_boundaries = num_boundaries + 1
num_bds = num_bds + 1
self.assertEqual(num_bds, 1)
self.assertEqual(num_boundaries, len(boundaries2))
store.dropAll()
def retrieve(self, request, bds=None, pk=None):
if bds is not None:
if not re.match(r'^[A-Za-z0-9]+$', pk):
return Response({
'status': 'Bad request',
},
status=status.HTTP_400_BAD_REQUEST)
try:
boundary_dataset = self.store.query_by_boundary_in_boundary_datasets(
bds, Boundary(boundary_ID=BoundaryID(pk)))
except:
return Response({
'status': 'Bad request',
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
serializer = self.serializer_class(instance=boundary_dataset,
many=True)
else:
try:
boundary_dataset = self.store.query_by_boundary_dataset_id(pk)
except:
return Response({
'status': 'Bad request',
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
serializer = self.serializer_class(instance=boundary_dataset,
many=True)
return Response(serializer.data)
def destroy(self, request, bds=None, pk=None):
if bds is not None:
if not re.match(r'^[A-Za-z0-9]+$', pk):
return Response({
'status': 'Bad request',
},
status=status.HTTP_400_BAD_REQUEST)
try:
result = self.store.delete_boundary_in_boundary_datasets(
bds, Boundary(boundary_ID=BoundaryID(pk)))
if result == 0:
return Response(status=status.HTTP_404_NOT_FOUND)
else:
return Response(status=status.HTTP_204_NO_CONTENT)
except:
return Response({
'status': 'Bad request',
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
try:
result = self.store.delete_boundary_dataset(pk)
if result == 0:
return Response(status=status.HTTP_404_NOT_FOUND)
else:
return Response(status=status.HTTP_204_NO_CONTENT)
except:
return Response({
'status': 'Bad request',
},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def to_internal_value(self, data):
bds = BoundaryDataSet(id='')
for item in data:
if not re.match(r'^[A-Za-z0-9]+$', item['boundary']):
raise ValidationError('Incorrect format: ' + item['boundary'])
bds.add(Boundary(boundary_ID=BoundaryID(item['boundary'])),
Data(item['data']))
return bds.boundary_data_set
def __init__(self,
boundary_ID=None,
cells=None,
dggs=rHEALPix(N_side=3, north_square=0, south_square=0)):
"""
:param boundary_ID: boundary identifier, of type BoundaryID
:param cells: list of identifiers of the cells that make up the boundary, [ CellID, CellID ... ]
:param dggs: Discrete Global Grid System, rHEALPix by default
"""
self.boundary_ID = boundary_ID
self.cells = cells
self.dggs = dggs
assert boundary_ID is not None or cells is not None
if cells is None:
cells = []
cell_ID = ''
first = True
for char in boundary_ID.value:
if char in self.dggs.cells_R0:
if not first:
cells.append(CellID(cell_ID))
else:
first = False
cell_ID = char
else:
cell_ID = cell_ID + char
cells.append(CellID(cell_ID))
cell_ids = sorted([cell.value for cell in cells])
self.cells = [CellID(id) for id in cell_ids]
if boundary_ID is None:
cell_ids = sorted([cell.value for cell in cells])
self.cells = [CellID(id) for id in cell_ids]
boundary_ID = ''
for cell_ID in self.cells:
boundary_ID = boundary_ID + cell_ID.value
self.boundary_ID = BoundaryID(boundary_ID)
refinement_set = {}
for cell in cells:
if cell.get_refinement() in refinement_set:
cell_list = refinement_set[cell.get_refinement()]
cell_list.append(cell)
else:
refinement_set[cell.get_refinement()] = [cell]
grids_list = []
for refinement, cell_list in refinement_set.items():
grids_list.append(Grid(refinement, cells=cell_list))
def sort_by_refinement_level(grid):
return grid.refinement_level
grids_list.sort(key=sort_by_refinement_level)
self.grids = grids_list
def test_delete_boundary(self):
store.dropAll()
bds = BoundaryDataSet("id")
boundaries = [
'O23P12P34S56', 'P10P11P2', 'N0', 'N8O2P0', 'O6S0S1S2', 'Q'
]
for boundary in boundaries:
bds.add(Boundary(boundary_ID=BoundaryID(boundary)), Data(""))
store.insert(bds)
deleted_boundaries = store.delete_boundary(
(Boundary(boundary_ID=BoundaryID('O23P12P34S56'))))
self.assertEqual(deleted_boundaries, 1)
stored_boundaries = store.query_by_boundary(
(Boundary(boundary_ID=BoundaryID('O23P12P34S56'))))
self.assertEqual(stored_boundaries.__len__(), 0)
store.dropAll()
def test_query_by_boundary(self):
store.dropAll()
bds = BoundaryDataSet("id")
boundaries = [
'O23P12P34S56', 'P10P11P2', 'N0', 'N8O2P0', 'O6S0S1S2', 'Q'
]
for boundary in boundaries:
bds.add(Boundary(boundary_ID=BoundaryID(boundary)), Data(""))
store.insert(bds)
stored_boundaries = store.query_by_boundary(
(Boundary(boundary_ID=BoundaryID('O23P12P34S56'))))
num_boundaries = 0
for boundary in stored_boundaries:
assert boundaries.__contains__(boundary[0].AUID_to_CUIDs())
num_boundaries = num_boundaries + 1
self.assertEqual(num_boundaries, 1)
store.dropAll()
def test_boundary_from_boundary_ID(self):
boundary = Boundary(boundary_ID=BoundaryID('N11N12N13N88O0P123S34567'))
self.assertEqual(boundary.cells, [
CellID('N11'),
CellID('N12'),
CellID('N13'),
CellID('N88'),
CellID('O0'),
CellID('P123'),
CellID('S34567')
])
def test_optimize_boundary(self):
boundary = Boundary(boundary_ID=BoundaryID('N11N12N2N3'))
optimal_boundary = boundary.optimize()
self.assertEqual(optimal_boundary.boundary_ID.value,
"RN11$))2$)))2$))3$))))")
self.assertEqual(optimal_boundary.is_optimal(), True)
boundary = Boundary(
boundary_ID=BoundaryID('N11N20N21N22N23N24N25N26N27N28'))
self.assertEqual(boundary.boundary_ID.value,
"N11N20N21N22N23N24N25N26N27N28")
self.assertEqual(boundary.is_optimal(), False)
optimal_boundary = boundary.optimize()
self.assertEqual(optimal_boundary.boundary_ID.value, "RN11$)))2$))))")
self.assertEqual(optimal_boundary.is_optimal(), True)
boundary = Boundary(boundary_ID=BoundaryID(
'N7N00N01N02N03N04N05N06N07N08N11N21N22N23N24N25N26N27N28N200N201N202N203N204N205N206N207N208N9878'
))
optimal_boundary = boundary.optimize()
self.assertEqual(optimal_boundary.boundary_ID.value,
"RN0$))11$)))2$))7$))9878$)))))))")
self.assertEqual(optimal_boundary.is_optimal(), True)
def get_boundary_dataset_from_shp_file(self,
dir,
id,
with_ids,
refinement=None,
unic_data=False):
import os
import glob
os.chdir(dir)
boundaries = []
for file in glob.glob('*.shp'):
boundaries.append(fiona.open(file))
bds = BoundaryDataSet(id=id)
for boundary in boundaries:
data = {}
boundary_id = ''
first = True
for polygon in boundary:
if with_ids:
boundary_id = boundary_id + polygon['properties']['id']
else:
assert refinement is not None
cell = self.get_cell_ID(polygon, int(refinement))
boundary_id = boundary_id + cell.value
if not unic_data:
if 'data' in polygon['properties']:
data[polygon['properties']
['id']] = polygon['properties']['data']
else:
data[polygon['properties']
['id']] = polygon['properties']
elif unic_data and first:
if 'data' in polygon['properties']:
data = polygon['properties']['data']
else:
data = polygon['properties']
bds.add(boundary=Boundary(boundary_ID=BoundaryID(boundary_id)),
data=Data(data))
return bds
def __init__(self,
refinement_level,
boundary_ID=None,
cells=None,
dggs=rHEALPix(N_side=3, north_square=0, south_square=0)):
"""
:param refinement_level
:param boundary_ID: boundary identifier, of type BoundaryID
:param cells: list of identifiers of the cells that make up the boundary, [ CellID, CellID ... ]
:param dggs: Discrete Global Grid System, rHEALPix by default
"""
self.boundary_ID = boundary_ID
self.cells = cells
self.dggs = dggs
self.refinement_level = refinement_level
assert boundary_ID is not None or cells is not None
if cells is None:
cells = []
cell_ID = ''
first = True
for char in boundary_ID.value:
if char in self.dggs.cells_R0:
if not first:
cells.append(CellID(cell_ID))
else:
first = False
cell_ID = char
else:
cell_ID = cell_ID + char
cells.append(CellID(cell_ID))
cell_ids = sorted([cell.value for cell in cells])
self.cells = [CellID(id) for id in cell_ids]
if boundary_ID is None:
cell_ids = sorted([cell.value for cell in cells])
self.cells = [CellID(id) for id in cell_ids]
boundary_ID = ''
for cell_ID in self.cells:
boundary_ID = boundary_ID + cell_ID.value
self.boundary_ID = BoundaryID(boundary_ID)
def add_list(self, cell_data_list):
"""
Add all pairs (CellID, Data) in a list
:paramcell_data_list: list of cells and associated data tuples
"""
for (cell_id, data) in cell_data_list:
if cell_id not in self.cells:
self.cells.append(cell_id)
self.cell_data_set[cell_id.value] = (cell_id, data)
else:
print('Cell already exists in this dataset')
return -1
cell_ids = sorted([cell.value for cell in self.cells])
self.cells = [CellID(id) for id in cell_ids]
boundary_ID = ''
for cell_ID in self.cells:
boundary_ID = boundary_ID + cell_ID.value
self.boundary_ID = BoundaryID(boundary_ID)
def add(self, cell_id, data):
"""
Add a pair (CellID, Data)
:param cell_id: object of type CellID.
:param data: object of type Data.
"""
if cell_id not in self.cells:
self.cells.append(cell_id)
cell_ids = sorted([cell.value for cell in self.cells])
self.cells = [CellID(id) for id in cell_ids]
boundary_ID = ''
for cell_ID in self.cells:
boundary_ID = boundary_ID + cell_ID.value
self.boundary_ID = BoundaryID(boundary_ID)
self.cell_data_set[cell_id.value] = (cell_id, data)
else:
print('Cell already exists in this dataset')
return -1
def test_bbox(self):
boundary = Boundary(boundary_ID=BoundaryID('O0O1O3O4'))
bbox = [[[-179.9999997096064, -12.895312716341486],
[-120.00000018880363, -12.895312716341486],
[-120.00000018880363, 41.93785365811587],
[-179.9999997096064, 41.93785365811587],
[-179.9999997096064, -12.895312716341486]]]
self.assertEqual(boundary.get_bbox(), bbox)
boundary = Boundary(boundary_ID=BoundaryID('O0O1O3'))
bbox = [[[-179.9999997096064, -12.895312716341486],
[-120.00000018880363, -12.895312716341486],
[-120.00000018880363, 41.93785365811587],
[-179.9999997096064, 41.93785365811587],
[-179.9999997096064, -12.895312716341486]]]
self.assertEqual(boundary.get_bbox(), bbox)
boundary = Boundary(boundary_ID=BoundaryID('O1O3O4'))
bbox = [[[-179.9999997096064, -12.895312716341486],
[-120.00000018880363, -12.895312716341486],
[-120.00000018880363, 41.93785365811587],
[-179.9999997096064, 41.93785365811587],
[-179.9999997096064, -12.895312716341486]]]
self.assertEqual(boundary.get_bbox(), bbox)
boundary = Boundary(boundary_ID=BoundaryID('O0O4'))
bbox = [[[-179.9999997096064, -12.895312716341486],
[-120.00000018880363, -12.895312716341486],
[-120.00000018880363, 41.93785365811587],
[-179.9999997096064, 41.93785365811587],
[-179.9999997096064, -12.895312716341486]]]
self.assertEqual(boundary.get_bbox(), bbox)
boundary = Boundary(boundary_ID=BoundaryID('N5P1P2'))
bbox = [[[-89.99999763120867, 12.895313217732834],
[-5.735989944427416e-07, 12.895313217732834],
[-5.735989944427416e-07, 74.42400629900254],
[-89.99999763120867, 74.42400629900254],
[-89.99999763120867, 12.895313217732834]]]
self.assertEqual(boundary.get_bbox(), bbox)
boundary = Boundary(boundary_ID=BoundaryID('Q6Q7S7'))
bbox = [[[1.9224187603958446e-06, -74.4240062287476],
[89.9999976312087, -74.4240062287476],
[89.9999976312087, -12.895313217732834],
[1.9224187603958446e-06, -12.895313217732834],
[1.9224187603958446e-06, -74.4240062287476]]]
self.assertEqual(boundary.get_bbox(), bbox)
def __init__(self,
id,
dggs=rHEALPix(N_side=3, north_square=0, south_square=0),
cell_data_set=None):
"""
:param boundary_ID: boundary identifier, of type BoundaryID
:param cells: list of identifiers of the cells that make up the boundary, [ CellID, CellID ... ]
:param dggs: Discrete Global Grid System, rHEALPix by default
:param cell_data_set: dictionary with CellID.value as key and (CellID, Data) as value:
{
CellID.value: (CellID, Data)
}
"""
assert id is not None
self.id = id
self.boundary_ID = ''
self.cells = []
self.dggs = dggs
if cell_data_set is None:
cell_data_set = {}
else:
cells = []
for id, (cell_id, data) in cell_data_set.items():
if cell_id not in self.cells:
cells.append(cell_id)
else:
print('Cell already exists in this dataset')
cell_ids = sorted([cell.value for cell in cells])
self.cells = [CellID(id) for id in cell_ids]
boundary_ID = ''
for cell_ID in self.cells:
boundary_ID = boundary_ID + cell_ID.value
self.boundary_ID = BoundaryID(boundary_ID)
self.cell_data_set = cell_data_set
def test_API(self, n_person):
print('TEST START')
store = BoundaryStore()
store.dropAll()
boundary_dataset_test = {}
all_bds_test = []
all_boundaries = []
boundary_test = []
test_boundary_id = ''
number_person = 0
test_person_number = ''
for person in self.bds[0:n_person]:
number_person = number_person + 1
bds = []
bds_test = []
for boundaries in person['boundaries']:
data = {}
boundary_id = ''
for polygon in boundaries:
boundary_id = boundary_id + polygon['properties']['id']
data[polygon['properties']['id']] = polygon['properties']
bds.append({'boundary': boundary_id, 'data': data})
optB = Boundary(boundary_ID=BoundaryID(boundary_id)).optimize()
bds_test.append({'AUID': optB.boundary_ID.value, 'boundary': optB.AUID_to_CUIDs(), 'data': data})
all_boundaries.append({'AUID': optB.boundary_ID.value, 'boundary': optB.AUID_to_CUIDs(), 'data': data})
test_boundary_id = boundary_id
boundary_test = [{'AUID': optB.boundary_ID.value, 'boundary': optB.AUID_to_CUIDs(), 'data': data}]
boundary_dataset = {"id": "persona" + str(number_person), 'boundary_data_set': bds}
test_person_number = "persona" + str(number_person)
boundary_dataset_test = {"id": "persona" + str(number_person), 'boundary_data_set': bds_test}
all_bds_test.append(boundary_dataset_test)
# POST BOUNDARY_DATASETS TEST
r = requests.post('http://127.0.0.1:8000/bdatasets/', json=boundary_dataset)
assert r.status_code == 201
# GET ALL BOUNDARY_DATASETS TEST
r = requests.get('http://127.0.0.1:8000/bdatasets/')
assert r.status_code == 200
json_test = json.dumps(all_bds_test)
json_data = json.dumps(r.json())
assert json_test == json_data
# GET BOUNDARY_DATASET TEST
r = requests.get('http://127.0.0.1:8000/bdatasets/' + test_person_number)
assert r.status_code == 200
json_test = json.dumps([boundary_dataset_test])
json_data = json.dumps(r.json())
assert json_test == json_data
# GET BOUNDARY IN BOUNDARY_DATASET TEST
r = requests.get('http://127.0.0.1:8000/bdatasets/' + test_person_number + "/" + test_boundary_id)
assert r.status_code == 200
boundary_in_boundary_dataset = {"id": test_person_number, 'boundary_data_set': boundary_test}
json_test = json.dumps([boundary_in_boundary_dataset])
json_data = json.dumps(r.json())
assert json_test == json_data
# GET ALL BOUNDARIES TEST
r = requests.get('http://127.0.0.1:8000/boundaries/')
assert r.status_code == 200
json_test = json.dumps(all_boundaries)
json_data = json.dumps(r.json())
assert json_test == json_data
# GET BOUNDARY TEST
r = requests.get('http://127.0.0.1:8000/boundaries/' + test_boundary_id)
assert r.status_code == 200
json_test = json.dumps(boundary_test)
json_data = json.dumps(r.json())
assert json_test == json_data
# DELETE BOUNDARY TEST
r = requests.delete('http://127.0.0.1:8000/boundaries/' + test_boundary_id)
assert r.status_code == 204
r = requests.get('http://127.0.0.1:8000/boundaries/')
assert r.status_code == 200
all_boundaries.pop()
json_test = json.dumps(all_boundaries)
json_data = json.dumps(r.json())
assert json_test == json_data
store.dropAll()
print('TEST FINISH')
def test_API_polygon_11(self):
print('TEST START')
store = BoundaryStore(MongoClient(port=27017).bds)
store.dropAll()
i = 0
data = {}
bds = []
boundary_id = ''
for polygon in self.shapes:
if i != 0:
bds.append({'boundary': boundary_id, 'data': data})
optB = Boundary(boundary_ID=BoundaryID(boundary_id)).optimize()
data = {}
boundary_id = ''
boundary_id = boundary_id + polygon['properties']['id']
data[polygon['properties']['id']] = polygon['properties']
i = i + 1
boundary_dataset = {'boundary_data_set': bds}
# POST BOUNDARY_DATASETS TEST
r = requests.post('http://127.0.0.1:8000/bdatasets/',
json=boundary_dataset)
assert r.status_code == 201
# GET BOUNDARY (POLYGON) TEST
params = {
'dlx': '-0.903563',
'dly': '41.644185',
'urx': '-0.902558',
'ury': '41.644762'
}
cells = [
Boundary(boundary_ID=BoundaryID(
'P22220720640')).optimize().boundary_ID.value,
Boundary(boundary_ID=BoundaryID(
'P22220720641')).optimize().boundary_ID.value,
Boundary(boundary_ID=BoundaryID(
'P22220720642')).optimize().boundary_ID.value,
Boundary(boundary_ID=BoundaryID(
'P22220720643')).optimize().boundary_ID.value,
Boundary(boundary_ID=BoundaryID(
'P22220720644')).optimize().boundary_ID.value,
Boundary(boundary_ID=BoundaryID(
'P22220720645')).optimize().boundary_ID.value
]
r = requests.get('http://127.0.0.1:8000/boundaries/', params=params)
assert r.status_code == 200
num_cells = 0
for boundary in r.json():
assert cells.__contains__(boundary['AUID'])
num_cells = num_cells + 1
assert num_cells == len(cells)
store.dropAll()
print('TEST FINISH')
def test_API(self):
print('TEST START')
store = BoundaryStore(MongoClient(port=27017).bds)
store.dropAll()
i = 0
data = {}
bds = []
boundary_id = ''
bds_test = []
boundary_test = []
test_boundary_id = ''
for polygon in self.shapes:
if i % 10 == 0 and i != 0:
bds.append({'boundary': boundary_id, 'data': data})
optB = Boundary(boundary_ID=BoundaryID(boundary_id)).optimize()
bds_test.append({
'AUID': optB.boundary_ID.value,
'boundary': optB.AUID_to_CUIDs(),
'data': data
})
test_boundary_id = boundary_id
boundary_test = [{
'AUID': optB.boundary_ID.value,
'boundary': optB.AUID_to_CUIDs(),
'data': data
}]
data = {}
boundary_id = ''
boundary_id = boundary_id + polygon['properties']['id']
data[polygon['properties']['id']] = polygon['properties']
i = i + 1
boundary_dataset = {'boundary_data_set': bds}
boundary_dataset_test = {'boundary_data_set': bds_test}
# POST BOUNDARY_DATASETS TEST
r = requests.post('http://127.0.0.1:8000/bdatasets/',
json=boundary_dataset)
assert r.status_code == 201
# GET ALL BOUNDARY_DATASETS TEST
r = requests.get('http://127.0.0.1:8000/bdatasets/')
json_test = json.dumps([boundary_dataset_test])
json_data = json.dumps(r.json())
assert r.status_code == 200
assert json_test == json_data
# GET BOUNDARY IN BOUNDARY_DATASET TEST
r = requests.get('http://127.0.0.1:8000/bdatasets/' + test_boundary_id)
json_test = json.dumps([boundary_dataset_test])
json_data = json.dumps(r.json())
assert r.status_code == 200
assert json_test == json_data
# GET ALL BOUNDARIES TEST
r = requests.get('http://127.0.0.1:8000/boundaries/')
json_test = json.dumps(bds_test)
json_data = json.dumps(r.json())
assert r.status_code == 200
assert json_test == json_data
# GET BOUNDARY TEST
r = requests.get('http://127.0.0.1:8000/boundaries/' +
test_boundary_id)
json_test = json.dumps(boundary_test)
json_data = json.dumps(r.json())
assert r.status_code == 200
assert json_test == json_data
# DELETE BOUNDARY TEST
r = requests.delete('http://127.0.0.1:8000/boundaries/' +
test_boundary_id)
assert r.status_code == 204
r = requests.get('http://127.0.0.1:8000/boundaries/')
bds_test.pop()
json_test = json.dumps(bds_test)
json_data = json.dumps(r.json())
assert r.status_code == 200
assert json_test == json_data
store.dropAll()
print('TEST FINISH')
def shp_file_from_boundary_cli(self, boundary_file, out_shp, bbox):
with open(boundary_file) as json_file:
boundary = json.load(json_file)
self.shp_file_from_boundary(Boundary(boundary_ID=BoundaryID(boundary['boundary'])), out_shp, bbox,
data=Data(boundary['data']))
def save(self, store, bds_id, boundary_id):
store.update_boundary_in_boundary_datasets(
bds_id,
Boundary(boundary_ID=BoundaryID(boundary_id)).optimize(),
Data(self.validated_data['data']))
