def get(self, model_id, prediction_id):
try:
prediction = PredictionService.get_prediction_by_id(prediction_id)
pred = {
"predictionsId": prediction.id,
"modelId": prediction.model_id,
"version": prediction.version,
"dockerUrl": prediction.docker_url,
"tileZoom": prediction.tile_zoom,
"logLink": prediction.log_link,
"modelLink": prediction.model_link,
"dockerLink": prediction.docker_link,
"saveLink": prediction.save_link,
"infSupertile": prediction.inf_supertile,
"tfrecordLink": prediction.tfrecord_link,
"checkpointLink": prediction.checkpoint_link,
"infList": prediction.inf_list,
"infBinary": prediction.inf_binary,
"infType": prediction.inf_type
}
return pred, 200
except Exception as e:
error_msg = f'Unhandled error: {str(e)}'
current_app.logger.error(error_msg)
return err(500, error_msg), 500
def post(self, model_id, prediction_id):
if CONFIG.EnvironmentConfig.ENVIRONMENT != "aws":
return err(501, "stack must be in 'aws' mode to use this endpoint"), 501
payload = request.data
tiler = tileschemes.WebMercator()
try:
prediction = PredictionService.get_prediction_by_id(prediction_id)
poly = shape(geojson.loads(payload))
project = partial(
pyproj.transform,
pyproj.Proj(init='epsg:4326'),
pyproj.Proj(init='epsg:3857')
)
poly = transform(project, poly)
tiles = tilecover.cover_geometry(tiler, poly, prediction.tile_zoom)
queue_name = "{stack}-models-{model}-prediction-{prediction}-queue".format(
stack=CONFIG.EnvironmentConfig.STACK,
model=model_id,
prediction=prediction_id
)
queue = boto3.resource('sqs').get_queue_by_name(
QueueName=queue_name
)
cache = []
for tile in tiles:
if len(cache) < 10:
cache.append({
"Id": str(tile.z) + "-" + str(tile.x) + "-" + str(tile.y),
"MessageBody": json.dumps({
"x": tile.x,
"y": tile.y,
"z": tile.z
})
})
else:
queue.send_messages(
Entries=cache
)
cache = []
return {}, 200
except Exception as e:
error_msg = f'Predction Tiler Error: {str(e)}'
current_app.logger.error(error_msg)
return err(500, error_msg), 500
def post(self, project_id, prediction_id):
"""
Retrain a model with validated predictions
---
produces:
- application/json
"""
if CONFIG.EnvironmentConfig.ENVIRONMENT != "aws":
return err(501, "stack must be in 'aws' mode to use this endpoint"), 501
if CONFIG.EnvironmentConfig.ASSET_BUCKET is None:
return err(501, "Not Configured"), 501
payload = request.get_json()
pred = PredictionService.get_prediction_by_id(prediction_id)
try:
batch = boto3.client(
service_name="batch",
region_name="us-east-1",
endpoint_url="https://batch.us-east-1.amazonaws.com",
)
# Submit to AWS Batch to convert to ECR image
job = batch.submit_job(
jobName=CONFIG.EnvironmentConfig.STACK + "-retrain",
jobQueue=CONFIG.EnvironmentConfig.STACK + "-gpu-queue",
jobDefinition=CONFIG.EnvironmentConfig.STACK + "-retrain-job",
containerOverrides={
"environment": [
{"name": "MODEL_ID", "value": str(project_id)},
{"name": "PREDICTION_ID", "value": str(prediction_id)},
{"name": "TILE_ENDPOINT", "value": str(pred.imagery_id)},
{"name": "CONFIG_RETRAIN", "value": str(json.dumps(payload))},
]
},
)
TaskService.create(
{
"pred_id": prediction_id,
"type": "retrain",
"batch_id": job.get("jobId"),
}
)
except Exception:
current_app.logger.error(traceback.format_exc())
return err(500, "Failed to start GPU Retrain"), 500
def post(self, project_id, prediction_id):
"""
Import a file of GeoJSON inferences into the prediction
Typically used to seed TFRecord creation preceding model creation
---
produces:
- application/json
responses:
200:
description: ID of the prediction
400:
description: Invalid Request
500:
description: Internal Server Error
"""
files = list(request.files.keys())
if len(files) == 0:
return err(400, "File not found in request"), 400
inferences = request.files[files[0]]
try:
pred = PredictionService.get_prediction_by_id(prediction_id)
infstream = io.BytesIO()
inferences.save(infstream)
inferences = infstream.getvalue().decode("UTF-8").split("\n")
data = []
for inf in inferences:
if len(inf) == 0:
continue
data.append(geojson.loads(inf))
PredictionTileService.create_geojson(pred, data)
except InvalidGeojson as e:
return err(400, str(e)), 400
except PredictionsNotFound:
return err(404, "Predictions not found"), 404
except Exception as e:
current_app.logger.error(traceback.format_exc())
error_msg = f"Unhandled error: {str(e)}"
return err(500, error_msg), 500
def post(self, model_id, prediction_id):
if CONFIG.EnvironmentConfig.ENVIRONMENT != "aws":
return err(501, "stack must be in 'aws' mode to use this endpoint"), 501
payload = request.get_json()
if payload.get("imagery") is None:
return err(400, "imagery key required in body"), 400
pred = PredictionService.get_prediction_by_id(prediction_id)
image = "models-{model}-prediction-{prediction}".format(
model=model_id,
prediction=prediction_id
)
stack = "{stack}-{image}".format(
stack=CONFIG.EnvironmentConfig.STACK,
image=image
)
template = ''
with open('cloudformation/prediction.template.json', 'r') as file:
template = file.read()
try:
boto3.client('cloudformation').create_stack(
StackName=stack,
TemplateBody=template,
Tags = payload.get("tags", []),
Parameters=[{
'ParameterKey': 'GitSha',
'ParameterValue': CONFIG.EnvironmentConfig.GitSha,
},{
'ParameterKey': 'MachineAuth',
'ParameterValue': CONFIG.EnvironmentConfig.MACHINE_AUTH
},{
'ParameterKey': 'StackName',
'ParameterValue': CONFIG.EnvironmentConfig.STACK,
},{
'ParameterKey': 'ImageTag',
'ParameterValue': image,
},{
'ParameterKey': 'Inferences',
'ParameterValue': pred.inf_list,
},{
'ParameterKey': 'ModelId',
'ParameterValue': str(model_id)
},{
'ParameterKey': 'PredictionId',
'ParameterValue': str(prediction_id)
},{
'ParameterKey': 'ImageryId',
'ParameterValue': str(payload["imagery"]),
},{
'ParameterKey': 'MaxSize',
'ParameterValue': payload.get("maxSize", "1"),
},{
'ParameterKey': 'MaxConcurrency',
'ParameterValue': payload.get("maxConcurrency", "50"),
},{
'ParameterKey': 'InfSupertile',
'ParameterValue': str(pred.inf_supertile),
}],
Capabilities=[
'CAPABILITY_NAMED_IAM'
],
OnFailure='ROLLBACK',
)
return self.get(model_id, prediction_id)
except Exception as e:
error_msg = f'Prediction Stack Creation Error: {str(e)}'
current_app.logger.error(error_msg)
return err(500, "Failed to create stack info"), 500
def get(self, model_id, prediction_id):
req_format = request.args.get('format', 'geojson')
req_inferences = request.args.get('inferences', 'all')
req_threshold = request.args.get('threshold', '0')
req_threshold = float(req_threshold)
stream = PredictionService.export(prediction_id)
inferences = PredictionService.inferences(prediction_id)
pred = PredictionService.get_prediction_by_id(prediction_id)
first = False
if req_inferences != 'all':
inferences = [ req_inferences ]
def generate_npz():
nonlocal req_threshold
labels_dict ={}
for row in stream:
if req_inferences != 'all' and row[3].get(req_inferences) is None:
continue
if req_inferences != 'all' and row[3].get(req_inferences) <= req_threshold:
continue
if row[4]:
i_lst = pred.inf_list.split(",")
#convert raw predictions into 0 or 1 based on threshold
raw_pred = []
for num, inference in enumerate(i_lst):
raw_pred.append(row[3][inference])
if req_inferences == 'all':
req_threshold = request.args.get('threshold', '0.5')
req_threshold = float(req_threshold)
l = [1 if score >= req_threshold else 0 for score in raw_pred]
#convert quadkey to x-y-z
t = '-'.join([str(i) for i in mercantile.quadkey_to_tile(row[1])])
# special case for binary
if (pred.inf_binary) and (len(i_lst) != 2):
return err(400, "binary models must have two catagories"), 400
if (len(i_lst) == 2) and (pred.inf_binary):
if list(row[4].values())[0]: #validated and true, keep original
labels_dict.update({t:l})
else:
if l == [1, 0]:
l = [0, 1]
else:
l = [1, 0]
labels_dict.update({t:l})
else:
# for multi-label
for key in list(row[4].keys()):
i = i_lst.index(key)
if not row[4][key]:
if l[i] == 0:
l[i] = 1
else:
l[i] = 0
labels_dict.update({t:l})
if not labels_dict:
raise NoValid
bytestream = io.BytesIO()
np.savez(bytestream, **labels_dict)
return bytestream.getvalue()
def generate():
nonlocal first
if req_format == "geojson":
yield '{ "type": "FeatureCollection", "features": ['
elif req_format == "csv":
output = io.StringIO()
rowdata = ["ID", "QuadKey", "QuadKeyGeom"]
rowdata.extend(inferences)
csv.writer(output, quoting=csv.QUOTE_NONNUMERIC).writerow(rowdata)
yield output.getvalue()
for row in stream:
if req_inferences != 'all' and row[3].get(req_inferences) is None:
continue
if req_inferences != 'all' and row[3].get(req_inferences) <= req_threshold:
continue
if req_format == "geojson" or req_format == "geojsonld":
properties_dict = {}
if row[4]:
properties_dict = row[3]
valid_dict = {}
valid_dict.update({'validity': row[4]})
properties_dict.update(valid_dict)
else:
properties_dict = row[3]
feat = {
"id": row[0],
"quadkey": row[1],
"type": "Feature",
"properties": properties_dict,
"geometry": json.loads(row[2])
}
if req_format == "geojsonld":
yield json.dumps(feat) + '\n'
elif req_format == "geojson":
if first == False:
first = True
yield '\n' + json.dumps(feat)
else:
yield ',\n' + json.dumps(feat)
elif req_format == "csv":
output = io.StringIO()
rowdata = [ row[0], row[1], row[2]]
for inf in inferences:
rowdata.append(row[3].get(inf, 0.0))
csv.writer(output, quoting=csv.QUOTE_NONNUMERIC).writerow(rowdata)
yield output.getvalue()
else:
return err(501, "not a valid export type, valid export types are: geojson, csv, and npz"), 501
if req_format == "geojson":
yield ']}'
if req_format == "csv":
mime = "text/csv"
elif req_format == "geojson":
mime = "application/geo+json"
elif req_format == "geojsonld":
mime = "application/geo+json-seq"
elif req_format == "npz":
mime = "application/npz"
if req_format == "npz":
try:
npz = generate_npz()
return Response(
response = generate_npz(),
mimetype = mime,
status = 200,
headers = {
"Content-Disposition": 'attachment; filename="export.' + req_format + '"'
}
)
except NoValid:
return err(400, "Can only return npz if predictions are validated. Currently there are no valid predictions"), 400
else:
return Response(
generate(),
mimetype = mime,
status = 200,
headers = {
"Content-Disposition": 'attachment; filename="export.' + req_format + '"'
}
)
def post(self, prediction_id):
"""
Submit tile level predictions
---
produces:
- application/json
parameters:
- in: body
name: body
required: true
type: string
description: JSON object of predictions
schema:
properties:
predictionId:
type: integer
description: Prediction ID
required: true
predictions:
type: array
items:
type: object
schema:
properties:
quadkey:
type: string
description: quadkey of the tile
required: true
centroid:
type: array
items:
type: float
required: true
predictions:
type: object
schema:
properties:
ml_prediction:
type: float
responses:
200:
description: ID of the prediction
400:
description: Invalid Request
500:
description: Internal Server Error
"""
try:
prediction_dto = PredictionService.get_prediction_by_id(
prediction_id)
data = request.get_json()
if (len(data['predictions']) == 0):
return {"error": "Error validating request"}, 400
PredictionTileService.create(prediction_dto, data)
except PredictionsNotFound:
return {"error": "Prediction not found"}, 404
except Exception as e:
error_msg = f'Unhandled error: {str(e)}'
current_app.logger.error(error_msg)
return {"error": error_msg}, 500
def payload(integration_id: int, payload: dict):
integration = IntegrationService.get_secrets(integration_id)
if integration is None:
raise IntegrationNotFound('Integration Not Found')
if integration.integration != "maproulette":
raise Exception("Only MapRoulette Integrations supported");
for ele in ['prediction', 'project', 'project_desc', 'challenge', 'challenge_instr', 'threshold', 'inferences']:
if payload.get(ele) is None:
raise Exception('Missing ' + ele + ' key in body')
auth = integration.auth
if payload.get('auth') is not None:
auth = payload.get('auth')
parsed = urlparse(integration.url)
config = maproulette.Configuration(
api_key=auth,
hostname=parsed.netloc,
protocol=parsed.scheme
)
project_api = maproulette.Project(config)
challenge_api = maproulette.Challenge(config)
try:
project = project_api.get_project_by_name(
project_name=payload.get('project')
)
except:
project = project_api.create_project(
data={
"name": payload.get('project'),
"display_name": payload.get('project'),
"description": payload.get('project_desc'),
"enabled": True
}
)
try:
challenge = challenge_api.create_challenge(
data={
'name': payload.get('challenge'),
'parent': project['data']['id'],
'instruction': payload.get('challenge_instr')
}
)
except Exception as e:
raise e
req_inferences = payload.get('inferences', 'all')
req_threshold = float(payload.get('threshold', '0'))
stream = PredictionService.export(int(payload.get('prediction')))
inferences = PredictionService.inferences(int(payload.get('prediction')))
pred = PredictionService.get_prediction_by_id(int(payload.get('prediction')))
if req_inferences != 'all':
inferences = [ req_inferences ]
fc = {
'type': 'FeatureCollection',
'features': []
}
for row in stream:
if req_inferences != 'all' and row[3].get(req_inferences) is None:
continue
if req_inferences != 'all' and row[3].get(req_inferences) <= req_threshold:
continue
properties_dict = {}
if row[4]:
properties_dict = row[3]
valid_dict = {}
valid_dict.update({'validity': row[4]})
properties_dict.update(valid_dict)
feat = {
"id": row[0],
"quadkey": row[1],
"type": "Feature",
"properties": properties_dict,
"geometry": json.loads(row[2])
}
fc['features'].append(feat)
challenge_api.add_tasks_to_challenge(
challenge_id=challenge['data']['id'],
data=fc
)
return {
"project": project['data']['id'],
"challenge": challenge['data']['id']
}
def post(project_id, prediction_id):
if CONFIG.EnvironmentConfig.ENVIRONMENT != "aws":
return err(501,
"stack must be in 'aws' mode to use this endpoint"), 501
payload = request.get_json()
pred = PredictionService.get_prediction_by_id(prediction_id)
image = "models-{model}-prediction-{prediction}".format(
model=project_id, prediction=prediction_id)
stack = "{stack}-{image}".format(stack=CONFIG.EnvironmentConfig.STACK,
image=image)
template = ""
with open("cloudformation/prediction.template.json", "r") as file:
template = file.read()
try:
boto3.client("cloudformation").create_stack(
StackName=stack,
TemplateBody=template,
Tags=payload.get("tags", []),
Parameters=[
{
"ParameterKey": "GitSha",
"ParameterValue": CONFIG.EnvironmentConfig.GitSha,
},
{
"ParameterKey": "MachineAuth",
"ParameterValue": CONFIG.EnvironmentConfig.MACHINE_AUTH,
},
{
"ParameterKey": "StackName",
"ParameterValue": CONFIG.EnvironmentConfig.STACK,
},
{
"ParameterKey": "ImageTag",
"ParameterValue": image,
},
{
"ParameterKey": "Inferences",
"ParameterValue": pred.inf_list,
},
{
"ParameterKey": "ModelId",
"ParameterValue": str(project_id)
},
{
"ParameterKey": "PredictionId",
"ParameterValue": str(prediction_id)
},
{
"ParameterKey": "ImageryId",
"ParameterValue": str(pred.imagery_id),
},
{
"ParameterKey": "MaxSize",
"ParameterValue": payload.get("maxSize", "1"),
},
{
"ParameterKey": "MaxConcurrency",
"ParameterValue": payload.get("maxConcurrency", "50"),
},
{
"ParameterKey": "InfSupertile",
"ParameterValue": str(pred.inf_supertile),
},
],
Capabilities=["CAPABILITY_NAMED_IAM"],
OnFailure="ROLLBACK",
)
return {"status": "Stack Creation Initiated"}
except Exception:
current_app.logger.error(traceback.format_exc())
return err(500, "Failed to create stack info"), 500
def post(self, project_id, prediction_id):
"""
Given a GeoJSON, xyz list, or tile list, submit it to the SQS queue
---
produces:
- application/json
responses:
200:
description: Status Update
"""
if CONFIG.EnvironmentConfig.ENVIRONMENT != "aws":
return err(501, "stack must be in 'aws' mode to use this endpoint"), 501
payload = request.data
tiler = tileschemes.WebMercator()
try:
prediction = PredictionService.get_prediction_by_id(prediction_id)
imagery = ImageryService.get(prediction.imagery_id)
queue_name = "{stack}-models-{model}-prediction-{prediction}-queue".format(
stack=CONFIG.EnvironmentConfig.STACK,
model=project_id,
prediction=prediction_id,
)
queue = boto3.resource("sqs").get_queue_by_name(QueueName=queue_name)
tiles = []
payloadjson = json.loads(payload)
if imagery["fmt"] == "wms":
if type(payloadjson) is list:
for tile in payloadjson:
tile = tile.split("-")
tiles.append(
mercantile.Tile(int(tile[0]), int(tile[1]), int(tile[2]))
)
else:
poly = shape(geojson.loads(payload))
project = partial(
pyproj.transform,
pyproj.Proj(init="epsg:4326"),
pyproj.Proj(init="epsg:3857"),
)
poly = transform(project, poly)
tiles = tilecover.cover_geometry(tiler, poly, prediction.tile_zoom)
cache = []
for tile in tiles:
cache.append(
{
"Id": str(tile.z) + "-" + str(tile.x) + "-" + str(tile.y),
"MessageBody": json.dumps(
{
"name": "{x}-{y}-{z}".format(
x=tile.x, y=tile.y, z=tile.z
),
"url": imagery["url"].format(
x=tile.x, y=tile.y, z=tile.z
),
"bounds": mercantile.bounds(tile.x, tile.y, tile.z),
"x": tile.x,
"y": tile.y,
"z": tile.z,
}
),
}
)
if len(cache) == 10:
queue.send_messages(Entries=cache)
cache = []
if len(cache) > 0:
queue.send_messages(Entries=cache)
return {}, 200
elif imagery["fmt"] == "list":
r = requests.get(imagery["url"])
r.raise_for_status()
f = StringIO(r.text)
cache = []
for row in csv.reader(f, delimiter=","):
cache.append(
{
"Id": row[0],
"MessageBody": json.dumps(
{
"name": row[0],
"url": row[1],
"bounds": row[2].split(","),
}
),
}
)
if len(cache) == 10:
queue.send_messages(Entries=cache)
cache = []
if len(cache) > 0:
queue.send_messages(Entries=cache)
return {}, 200
else:
return err(400, "Unknown imagery type"), 400
except Exception as e:
current_app.logger.error(traceback.format_exc())
error_msg = f"Prediction Tiler Error: {str(e)}"
return err(500, error_msg), 500
def get(self, project_id, prediction_id):
"""
Export Geospatial Predictions
---
parameters:
- name: project_id
in: path
schema:
type: integer
minimum: 0
description: The ID of the Project
- name: prediction_id
in: path
schema:
type: integer
minimum: 0
description: The ID of the Project
- name: format
in: query
schema:
type: string
default: geojson
enum:
- geojson
- geojsonseq
- csv
description: The format to provide records in
- name: inferences
in: query
schema:
type: string
default: all
description: Return all inferences or only a single inference
- name: threshold
in: query
schema:
type: integer
default: 0
minimum: 0
maximum: 1
description: The confidence threshold to apply to exported inferences
responses:
200:
description: Exported Data
"""
req_format = request.args.get("format", "geojson")
req_inferences = request.args.get("inferences", "all")
req_threshold = request.args.get("threshold", "0")
req_threshold = float(req_threshold)
stream = PredictionService.export(prediction_id)
inferences = PredictionService.inferences(prediction_id)
pred = PredictionService.get_prediction_by_id(prediction_id)
hint = pred.hint
z = pred.tile_zoom
i_info = ImageryService.get(pred.imagery_id)
c_list = ImageryService.get(pred.imagery_id)
first = False
if req_inferences != "all":
inferences = [req_inferences]
def generate_npz():
nonlocal req_threshold
nonlocal hint
nonlocal z
nonlocal i_info
nonlocal c_list
# get chip list csv as dataframe to match up chip-lst name + geometry with geometry in the predictions database
labels_dict = {}
for row in stream:
if req_inferences != "all" and row[3].get(req_inferences) is None:
continue
if (
req_inferences != "all"
and row[3].get(req_inferences) <= req_threshold
):
continue
# set labels.npz key to be x-y-z tile either from quadkey or wkt geometry
if i_info["fmt"] == "wms":
if row[1]:
t = "-".join(
[str(i) for i in mercantile.quadkey_to_tile(row[1])]
)
else:
s = shape(json.loads(row[2])).centroid
t = "-".join([str(i) for i in mercantile.tile(s.x, s.y, z)])
if i_info["fmt"] == "list":
r = requests.get(c_list["url"])
df = pd.read_csv(io.StringIO(r.text))
df["c"] = df["bounds"].apply(
lambda x: box(*[float(n) for n in x.split(",")])
)
gdf = gpd.GeoDataFrame(df, crs="EPSG:4326", geometry=df["c"])
# get tile name that where chip-list geom and geom in prediction row match
gdf_2 = gpd.GeoDataFrame(
{"geometry": [shape(json.loads(row[2]))]}, crs="EPSG:4326"
)
# To-DO account for no overlap case
i = gpd.overlay(gdf, gdf_2, how="intersection")
tiles_intersection = i["name"].tolist()
# convert raw predictions into 0 or 1 based on threshold
raw_pred = []
i_lst = pred.inf_list.split(",")
for num, inference in enumerate(i_lst):
raw_pred.append(row[3][inference])
if req_inferences == "all":
req_threshold = request.args.get("threshold", "0.5")
req_threshold = float(req_threshold)
binary_pred_list = [1 if score >= req_threshold else 0 for score in raw_pred]
# special case for training and not predictions
if hint == "training":
if i_info["fmt"] == "list":
for chip_name in tiles_intersection:
labels_dict.update({chip_name: binary_pred_list})
else:
labels_dict.update({t: binary_pred_list})
elif row[4]:
t = "-".join([str(i) for i in mercantile.quadkey_to_tile(row[1])])
# special case for binary
if pred.inf_binary and len(i_lst) != 2:
return err(400, "binary models must have two catagories"), 400
if len(i_lst) == 2 and pred.inf_binary:
if list(row[4].values())[
0
]: # validated and true, keep original
labels_dict.update({t: binary_pred_list})
else:
if binary_pred_list == [1, 0]:
binary_pred_list = [0, 1]
else:
binary_pred_list = [1, 0]
labels_dict.update({t: binary_pred_list})
else:
# for multi-label
for key in list(row[4].keys()):
i = i_lst.index(key)
if not row[4][key]:
if binary_pred_list[i] == 0:
binary_pred_list[i] = 1
else:
binary_pred_list[i] = 0
labels_dict.update({t: binary_pred_list})
if not labels_dict:
raise NoValid
bytestream = io.BytesIO()
np.savez(bytestream, **labels_dict)
return bytestream.getvalue()
def generate():
nonlocal first
if req_format == "geojson":
yield '{ "type": "FeatureCollection", "features": ['
elif req_format == "csv":
output = io.StringIO()
rowdata = ["ID", "QuadKey", "QuadKeyGeom"]
rowdata.extend(inferences)
csv.writer(output, quoting=csv.QUOTE_NONNUMERIC).writerow(rowdata)
yield output.getvalue()
for row in stream:
if req_inferences != "all" and row[3].get(req_inferences) is None:
continue
if (
req_inferences != "all"
and row[3].get(req_inferences) <= req_threshold
):
continue
if req_format == "geojson" or req_format == "geojsonld":
properties_dict = {}
if row[4]:
properties_dict = row[3]
valid_dict = {}
valid_dict.update({"validity": row[4]})
properties_dict.update(valid_dict)
else:
properties_dict = row[3]
feat = {
"id": row[0],
"quadkey": row[1],
"type": "Feature",
"properties": properties_dict,
"geometry": json.loads(row[2]),
}
if req_format == "geojsonld":
yield json.dumps(feat) + "\n"
elif req_format == "geojson":
if first is False:
first = True
yield "\n" + json.dumps(feat)
else:
yield ",\n" + json.dumps(feat)
elif req_format == "csv":
output = io.StringIO()
rowdata = [row[0], row[1], row[2]]
for inf in inferences:
rowdata.append(row[3].get(inf, 0.0))
csv.writer(output, quoting=csv.QUOTE_NONNUMERIC).writerow(rowdata)
yield output.getvalue()
else:
return (
err(
501,
"not a valid export type, valid export types are: geojson, csv, and npz",
),
501,
)
if req_format == "geojson":
yield "]}"
if req_format == "csv":
mime = "text/csv"
elif req_format == "geojson":
mime = "application/geo+json"
elif req_format == "geojsonld":
mime = "application/geo+json-seq"
elif req_format == "npz":
mime = "application/npz"
if req_format == "npz":
try:
return Response(
response=generate_npz(),
mimetype=mime,
status=200,
headers={
"Content-Disposition": 'attachment; filename="export.'
+ req_format
+ '"'
},
)
except NoValid:
return (
err(
400,
"Can only return npz if predictions are validated. Currently there are no valid predictions",
),
400,
)
else:
return Response(
generate(),
mimetype=mime,
status=200,
headers={
"Content-Disposition": 'attachment; filename="export.'
+ req_format
+ '"'
},
)