1184132321

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/vanvalenlab/deepcell-label/commit/<a class=hub.com/vanvalenlab/deepcell-label/commit/<a class="double-link" href="https://git"><a class=hub.com/vanvalenlab/deepcell-label/commit/<a class="double-link" href="https://git"><a class=hub.com/vanvalenlab/deepcell-label/commit/0b27807f270f951114033a7a66a3dd965b9b252a">0b27807f2<a href="https://github.com/vanvalenlab/deepcell-label/commit/0b27807f270f951114033a7a66a3dd965b9b252a">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/vanvalenlab/deepcell-label/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/vanvalenlab/deepcell-label/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/vanvalenlab/deepcell-label/commit/0b27807f270f951114033a7a66a3dd965b9b252a&quot;&gt;0b27807f2&lt;/a&gt;&lt;a href=&quot;https://github.com/vanvalenlab/deepcell-label/commit/0b27807f270f951114033a7a66a3dd965b9b252a&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/vanvalenlab/deepcell-label/commit/0b27807f270f951114033a7a66a3dd96&lt;/a&gt;5b9b252a&quot;>&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/vanvalenlab/deepcell-label/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/vanvalenlab/deepcell-label/commit/<a class="double-link" href="https://github.com/vanvalenlab/deepcell-label/commit/034dd75e8635bf5c64da42830733f49aff06e76d">034dd75e8</a><a href="https://github.com/vanvalenlab/deepcell-label/commit/0b27807f270f951114033a7a66a3dd965b9b252a">&amp;quot;&amp;gt;034dd75e8&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;034dd75e8&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/vanvalenlab/deepcell-label/commit/0b27807f270f951114033a7a66a3dd965b9b2&lt;/a&gt;52a&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/vanvalenlab/deepcell-label/commit/<a class="double-link" href="https://github.com/vanvalenlab/deepcell-label/commit/b8cbbaeaf">b8cbbaeaf">b8cbbaeaf</a>

Pull Request Pull Request #259: Merge refactors and improvements from tracking branches

Run Details

43 of 238 branches covered (18.07%)

Branch coverage included in aggregate %.

307 of 692 new or added lines in 53 files covered. (44.36%)

1556 of 3073 relevant lines covered (50.63%)

2.14 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

63.23

/deepcell_label/blueprints.py

"""Flask blueprint for modular routes."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import distutils
import distutils.util
import gzip
import json
import timeit
import traceback

from flask import abort
from flask import Blueprint
from flask import jsonify
from flask import request
from flask import redirect
from flask import current_app
from flask import send_file
from flask import make_response
from werkzeug.exceptions import HTTPException
import matplotlib
import pandas as pd

from deepcell_label.label import TrackEdit, ZStackEdit
from deepcell_label.models import Project
# from deepcell_label import loaders
from deepcell_label import url_loaders
from deepcell_label import exporters
from deepcell_label.config import S3_INPUT_BUCKET, S3_OUTPUT_BUCKET

bp = Blueprint('label', __name__)  # pylint: disable=C0103


@bp.route('/health')
def health():
    """Returns success if the application is ready."""
    return jsonify({'message': 'success'}), 200


@bp.errorhandler(url_loaders.InvalidExtension)
def handle_invalid_extension(error):
    response = jsonify(error.to_dict())
    response.status_code = error.status_code
    return response


@bp.errorhandler(Exception)
def handle_exception(error):
    """Handle all uncaught exceptions"""
    # pass through HTTP errors
    if isinstance(error, HTTPException):
        return error

    current_app.logger.error('Encountered %s: %s',
                             error.__class__.__name__, error, exc_info=1)

    traceback.print_exc()
    # now you're handling non-HTTP exceptions only
    return jsonify({'error': str(error)}), 500


@bp.route('/api/raw/<token>/<int:channel>/<int:frame>')
def raw(token, channel, frame):
    project = Project.get(token)
    if not project:
        return abort(404, description=f'project {token} not found')
    png = project.get_raw_png(channel, frame)
    return send_file(png, mimetype='image/png')


@bp.route('/api/labeled/<token>/<int:feature>/<int:frame>')
def labeled(token, feature, frame):
    project = Project.get(token)
    if not project:
        return abort(404, description=f'project {token} not found')
    png = project.get_labeled_png(feature, frame)
    return send_file(png, mimetype='image/png', cache_timeout=0)


@bp.route('/api/array/<token>/<int:feature>/<int:frame>')
def array(token, feature, frame):
    """
    """
    project = Project.get(token)
    if not project:
        return jsonify({'error': f'project {token} not found'}), 404
    labeled_array = project.get_labeled_array(feature, frame)
    content = gzip.compress(json.dumps(labeled_array.tolist()).encode('utf8'), 5)
    response = make_response(content)
    response.headers['Content-length'] = len(content)
    response.headers['Content-Encoding'] = 'gzip'
    return response
    # seg_array = project.get_labeled_array(feature, frame)
    # filename = f'{token}_array_feature{feature}_frame{frame}.npy'
    # return send_file(seg_array, attachment_filename=filename, cache_timeout=0)


@bp.route('/api/semantic-labels/<project_id>/<int:feature>')
def semantic_labels(project_id, feature):
    project = Project.get(project_id)
    if not project:
        return jsonify({'error': f'project {project_id} not found'}), 404
    cell_info = project.labels.cell_info[feature]
    df = pd.DataFrame(cell_info).T
    if df.parent.isnull().all():
        df['frame_div_parent'] = None
    else:
        df = df.join(df[['frame_div']], rsuffix='_parent', how='left', on='parent')
    df = df.rename(columns={'frame_div_parent': 'parentDivisionFrame',
                            'frame_div': 'divisionFrame'})
    return df.to_json(orient='index')


@bp.route('/api/colormap/<project_id>/<int:feature>')
def colormap(project_id, feature):
    project = Project.get(project_id)
    if not project:
        return jsonify({'error': f'project {project_id} not found'}), 404
    max_label = project.get_max_label(feature)
    colormap = matplotlib.pyplot.get_cmap('viridis', max_label)
    colors = list(map(matplotlib.colors.rgb2hex, colormap.colors))
    colors.insert(0, '#000000')  # No label (label 0) is black
    colors.append('#FFFFFF')  # New label (last label) is white
    response = make_response({'colors': colors})
    response.headers['Cache-Control'] = 'max-age=0'

    return response


@bp.route('/api/edit/<token>/<action_type>', methods=['POST'])
def edit(token, action_type):
    """
    Edit the labeling of the project and
    update the project in the database.
    """
    start = timeit.default_timer()
    # obtain 'info' parameter data sent by .js script
    info = {k: json.loads(v) for k, v in request.values.to_dict().items()}

    project = Project.get(token)
    if not project:
        return abort(404, description=f'project {token} not found')
    # TODO: remove frame/feature/channel columns from db schema? or keep them around
    # to load projects on the last edited frame
    project.frame = info['frame']
    project.feature = info['feature']
    project.channel = info['channel']
    del info['frame']
    del info['feature']
    del info['channel']

    edit = get_edit(project)
    edit.dispatch_action(action_type, info)
    project.create_memento(action_type)
    project.update()

    changed_frames = [frame.frame_id for frame in project.action.frames]
    payload = {'feature': project.feature, 'frames': changed_frames, 'labels': edit.labels_changed}

    current_app.logger.debug('Finished action %s for project %s in %s s.',
                             action_type, token,
                             timeit.default_timer() - start)
    return jsonify(payload)


@bp.route('/api/undo/<token>', methods=['POST'])
def undo(token):
    start = timeit.default_timer()

    project = Project.get(token)
    if not project:
        return abort(404, description=f'project {token} not found')
    payload = project.undo()

    current_app.logger.debug('Undid action for project %s finished in %s s.',
                             token, timeit.default_timer() - start)
    return jsonify(payload)


@bp.route('/api/redo/<token>', methods=['POST'])
def redo(token):
    start = timeit.default_timer()

    project = Project.get(token)
    if not project:
        return abort(404, description=f'project {token} not found')
    payload = project.redo()

    current_app.logger.debug('Redid action for project %s finished in %s s.',
                             token, timeit.default_timer() - start)
    return jsonify(payload)


@bp.route('/api/project/<token>', methods=['GET'])
def get_project(token):
    """
    Retrieve data from a project already in the Project table.
    """
    start = timeit.default_timer()
    project = Project.get(token)
    if not project:
        return abort(404, description=f'project {token} not found')
    payload = project.make_first_payload()
    current_app.logger.debug('Loaded project %s in %s s.',
                             project.token, timeit.default_timer() - start)
    return jsonify(payload)


# @bp.route('/api/project', methods=['POST'])
# def create_project():
#     """
#     Create a new Project.
#     """
#     start = timeit.default_timer()
#     loader = loaders.get_loader(request)
#     project = Project.create(loader)
#     current_app.logger.info('Created project from %s in %s s.',
#                             loader.path, timeit.default_timer() - start)
#     return jsonify({'projectId': project.token})


@bp.route('/api/project', methods=['POST'])
def create_project_from_url():
    """
    Create a new Project from URL.
    """
    start = timeit.default_timer()
    url_form = request.form
    loader = url_loaders.Loader(url_form)
    loader.load()
    project = Project.create(loader)
    current_app.logger.info('Created project from %s in %s s.',
                            loader.url, timeit.default_timer() - start)
    return jsonify({'projectId': project.token})


@bp.route('/downloadproject/<token>', methods=['GET'])
def download_project(token):
    """
    Download a .trk/.npz file from a DeepCell Label project.
    """
    project = Project.get(token)
    if not project:
        return abort(404, description=f'project {token} not found')

    exporter = exporters.Exporter(project)
    filestream = exporter.export()

    return send_file(filestream, as_attachment=True, attachment_filename=exporter.path)


@bp.route('/api/upload/<bucket>/<token>', methods=['GET', 'POST'])
def upload_project_to_s3(bucket, token):
    """Upload .trk/.npz data file to AWS S3 bucket."""
    start = timeit.default_timer()
    project = Project.get(token)
    if not project:
        return abort(404, description=f'project {token} not found')

    # Save data file and send to S3 bucket
    exporter = exporters.S3Exporter(project)
    exporter.export(bucket)
    # add "finished" timestamp and null out PickleType columns
    # project.finish()

    current_app.logger.debug('Uploaded %s to S3 bucket %s from project %s in %s s.',
                             exporter.path, bucket, token,
                             timeit.default_timer() - start)
    return {}


def get_edit(project):
    """Factory for Edit objects"""
    if project.is_track:
        return TrackEdit(project)
    else:
        return ZStackEdit(project)

1	"""Flask blueprint for modular routes."""
2	from __future__ import absolute_import	3✔
3	from __future__ import division	3✔
4	from __future__ import print_function	3✔
5
6	import distutils	3✔
7	import distutils.util	3✔
8	import gzip	3✔
9	import json	3✔
10	import timeit	3✔
11	import traceback	3✔
12
13	from flask import abort	3✔
14	from flask import Blueprint	3✔
15	from flask import jsonify	3✔
16	from flask import request	3✔
17	from flask import redirect	3✔
18	from flask import current_app	3✔
19	from flask import send_file	3✔
20	from flask import make_response	3✔
21	from werkzeug.exceptions import HTTPException	3✔
22	import matplotlib	3✔
23	import pandas as pd	3✔
24
25	from deepcell_label.label import TrackEdit, ZStackEdit	3✔
26	from deepcell_label.models import Project	3✔
27	# from deepcell_label import loaders
28	from deepcell_label import url_loaders	3✔
29	from deepcell_label import exporters	3✔
30	from deepcell_label.config import S3_INPUT_BUCKET, S3_OUTPUT_BUCKET	3✔
31
32	bp = Blueprint('label', __name__) # pylint: disable=C0103	3✔
33
34
35	@bp.route('/health')	3✔
36	def health():	1✔
37	"""Returns success if the application is ready."""
38	return jsonify({'message': 'success'}), 200	3✔
39
40
41	@bp.errorhandler(url_loaders.InvalidExtension)	3✔
42	def handle_invalid_extension(error):	1✔
43	response = jsonify(error.to_dict())	×
44	response.status_code = error.status_code	×
45	return response	×
46
47
48	@bp.errorhandler(Exception)	3✔
49	def handle_exception(error):	1✔
50	"""Handle all uncaught exceptions"""
51	# pass through HTTP errors
52	if isinstance(error, HTTPException):	3✔
53	return error	3✔
54
55	current_app.logger.error('Encountered %s: %s',	×
56	error.__class__.__name__, error, exc_info=1)
57
58	traceback.print_exc()	×
59	# now you're handling non-HTTP exceptions only
60	return jsonify({'error': str(error)}), 500	×
61
62
63	@bp.route('/api/raw/<token>/<int:channel>/<int:frame>')	3✔
64	def raw(token, channel, frame):	1✔
65	project = Project.get(token)	3✔
66	if not project:	3✔
67	return abort(404, description=f'project {token} not found')	×
68	png = project.get_raw_png(channel, frame)	3✔
69	return send_file(png, mimetype='image/png')	3✔
70
71
72	@bp.route('/api/labeled/<token>/<int:feature>/<int:frame>')	3✔
73	def labeled(token, feature, frame):	1✔
74	project = Project.get(token)	3✔
75	if not project:	3✔
76	return abort(404, description=f'project {token} not found')	×
77	png = project.get_labeled_png(feature, frame)	3✔
78	return send_file(png, mimetype='image/png', cache_timeout=0)	3✔
79
80
81	@bp.route('/api/array/<token>/<int:feature>/<int:frame>')	3✔
82	def array(token, feature, frame):	1✔
83	"""
84	"""
85	project = Project.get(token)	3✔
86	if not project:	3✔
87	return jsonify({'error': f'project {token} not found'}), 404	×
88	labeled_array = project.get_labeled_array(feature, frame)	3✔
89	content = gzip.compress(json.dumps(labeled_array.tolist()).encode('utf8'), 5)	3✔
90	response = make_response(content)	3✔
91	response.headers['Content-length'] = len(content)	3✔
92	response.headers['Content-Encoding'] = 'gzip'	3✔
93	return response	3✔
94	# seg_array = project.get_labeled_array(feature, frame)
95	# filename = f'{token}_array_feature{feature}_frame{frame}.npy'
96	# return send_file(seg_array, attachment_filename=filename, cache_timeout=0)
97
98
99	@bp.route('/api/semantic-labels/<project_id>/<int:feature>')	3✔
100	def semantic_labels(project_id, feature):	1✔
101	project = Project.get(project_id)	×
102	if not project:	×
103	return jsonify({'error': f'project {project_id} not found'}), 404	×
NEW 104	cell_info = project.labels.cell_info[feature]	×
NEW 105	df = pd.DataFrame(cell_info).T	×
NEW 106	if df.parent.isnull().all():	×
NEW 107	df['frame_div_parent'] = None	×
108	else:
NEW 109	df = df.join(df[['frame_div']], rsuffix='_parent', how='left', on='parent')	×
NEW 110	df = df.rename(columns={'frame_div_parent': 'parentDivisionFrame',	×
111	'frame_div': 'divisionFrame'})
NEW 112	return df.to_json(orient='index')	×
113
114
115	@bp.route('/api/colormap/<project_id>/<int:feature>')	3✔
116	def colormap(project_id, feature):	1✔
117	project = Project.get(project_id)	3✔
118	if not project:	3✔
119	return jsonify({'error': f'project {project_id} not found'}), 404	×
120	max_label = project.get_max_label(feature)	3✔
121	colormap = matplotlib.pyplot.get_cmap('viridis', max_label)	3✔
122	colors = list(map(matplotlib.colors.rgb2hex, colormap.colors))	3✔
123	colors.insert(0, '#000000') # No label (label 0) is black	3✔
124	colors.append('#FFFFFF') # New label (last label) is white	3✔
125	response = make_response({'colors': colors})	3✔
126	response.headers['Cache-Control'] = 'max-age=0'	3✔
127
128	return response	3✔
129
130
131	@bp.route('/api/edit/<token>/<action_type>', methods=['POST'])	3✔
132	def edit(token, action_type):	1✔
133	"""
134	Edit the labeling of the project and
135	update the project in the database.
136	"""
137	start = timeit.default_timer()	×
138	# obtain 'info' parameter data sent by .js script
139	info = {k: json.loads(v) for k, v in request.values.to_dict().items()}	×
140
141	project = Project.get(token)	×
142	if not project:	×
143	return abort(404, description=f'project {token} not found')	×
144	# TODO: remove frame/feature/channel columns from db schema? or keep them around
145	# to load projects on the last edited frame
146	project.frame = info['frame']	×
147	project.feature = info['feature']	×
148	project.channel = info['channel']	×
149	del info['frame']	×
150	del info['feature']	×
151	del info['channel']	×
152
153	edit = get_edit(project)	×
154	edit.dispatch_action(action_type, info)	×
155	project.create_memento(action_type)	×
156	project.update()	×
157
158	changed_frames = [frame.frame_id for frame in project.action.frames]	×
159	payload = {'feature': project.feature, 'frames': changed_frames, 'labels': edit.labels_changed}	×
160
161	current_app.logger.debug('Finished action %s for project %s in %s s.',	×
162	action_type, token,
163	timeit.default_timer() - start)
164	return jsonify(payload)	×
165
166
167	@bp.route('/api/undo/<token>', methods=['POST'])	3✔
168	def undo(token):	1✔
169	start = timeit.default_timer()	3✔
170
171	project = Project.get(token)	3✔
172	if not project:	3✔
173	return abort(404, description=f'project {token} not found')	3✔
174	payload = project.undo()	3✔
175
176	current_app.logger.debug('Undid action for project %s finished in %s s.',	3✔
177	token, timeit.default_timer() - start)
178	return jsonify(payload)	3✔
179
180
181	@bp.route('/api/redo/<token>', methods=['POST'])	3✔
182	def redo(token):	1✔
183	start = timeit.default_timer()	3✔
184
185	project = Project.get(token)	3✔
186	if not project:	3✔
187	return abort(404, description=f'project {token} not found')	3✔
188	payload = project.redo()	3✔
189
190	current_app.logger.debug('Redid action for project %s finished in %s s.',	3✔
191	token, timeit.default_timer() - start)
192	return jsonify(payload)	3✔
193
194
195	@bp.route('/api/project/<token>', methods=['GET'])	3✔
196	def get_project(token):	1✔
197	"""
198	Retrieve data from a project already in the Project table.
199	"""
200	start = timeit.default_timer()	3✔
201	project = Project.get(token)	3✔
202	if not project:	3✔
203	return abort(404, description=f'project {token} not found')	×
204	payload = project.make_first_payload()	3✔
205	current_app.logger.debug('Loaded project %s in %s s.',	3✔
206	project.token, timeit.default_timer() - start)
207	return jsonify(payload)	3✔
208
209
210	# @bp.route('/api/project', methods=['POST'])
211	# def create_project():
212	# """
213	# Create a new Project.
214	# """
215	# start = timeit.default_timer()
216	# loader = loaders.get_loader(request)
217	# project = Project.create(loader)
218	# current_app.logger.info('Created project from %s in %s s.',
219	# loader.path, timeit.default_timer() - start)
220	# return jsonify({'projectId': project.token})
221
222
223	@bp.route('/api/project', methods=['POST'])	3✔
224	def create_project_from_url():	1✔
225	"""
226	Create a new Project from URL.
227	"""
228	start = timeit.default_timer()	3✔
229	url_form = request.form	3✔
230	loader = url_loaders.Loader(url_form)	3✔
231	loader.load()	3✔
232	project = Project.create(loader)	3✔
233	current_app.logger.info('Created project from %s in %s s.',	3✔
234	loader.url, timeit.default_timer() - start)
235	return jsonify({'projectId': project.token})	3✔
236
237
238	@bp.route('/downloadproject/<token>', methods=['GET'])	3✔
239	def download_project(token):	1✔
240	"""
241	Download a .trk/.npz file from a DeepCell Label project.
242	"""
243	project = Project.get(token)	×
244	if not project:	×
245	return abort(404, description=f'project {token} not found')	×
246
247	exporter = exporters.Exporter(project)	×
248	filestream = exporter.export()	×
249
250	return send_file(filestream, as_attachment=True, attachment_filename=exporter.path)	×
251
252
253	@bp.route('/api/upload/<bucket>/<token>', methods=['GET', 'POST'])	3✔
254	def upload_project_to_s3(bucket, token):	1✔
255	"""Upload .trk/.npz data file to AWS S3 bucket."""
256	start = timeit.default_timer()	×
257	project = Project.get(token)	×
258	if not project:	×
259	return abort(404, description=f'project {token} not found')	×
260
261	# Save data file and send to S3 bucket
262	exporter = exporters.S3Exporter(project)	×
263	exporter.export(bucket)	×
264	# add "finished" timestamp and null out PickleType columns
265	# project.finish()
266
267	current_app.logger.debug('Uploaded %s to S3 bucket %s from project %s in %s s.',	×
268	exporter.path, bucket, token,
269	timeit.default_timer() - start)
270	return {}	×
271
272
273	def get_edit(project):	3✔
274	"""Factory for Edit objects"""
275	if project.is_track:	×
276	return TrackEdit(project)	×
277	else:
278	return ZStackEdit(project)	×

vanvalenlab / deepcell-label / 1184132321

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous