697 lines
21 KiB
Python
697 lines
21 KiB
Python
import distutils.util
|
|
import flask
|
|
from flask import request
|
|
import functools
|
|
import json
|
|
import math
|
|
import mimetypes
|
|
import os
|
|
import random
|
|
import re
|
|
import requests
|
|
import sys
|
|
import time
|
|
import uuid
|
|
import warnings
|
|
|
|
import phototagger
|
|
sys.path.append('C:\\git\\else\\Bytestring'); import bytestring
|
|
|
|
site = flask.Flask(__name__)
|
|
site.config.update(
|
|
SEND_FILE_MAX_AGE_DEFAULT=180,
|
|
TEMPLATES_AUTO_RELOAD=True,
|
|
)
|
|
site.jinja_env.add_extension('jinja2.ext.do')
|
|
|
|
P = phototagger.PhotoDB()
|
|
|
|
FILE_READ_CHUNK = 2 ** 20
|
|
|
|
MOTD_STRINGS = [
|
|
'Good morning, Paul. What will your first sequence of the day be?',
|
|
#'Buckle up, it\'s time to:',
|
|
]
|
|
|
|
THUMBDIR = phototagger.DEFAULT_THUMBDIR
|
|
ERROR_INVALID_ACTION = 'Invalid action'
|
|
ERROR_NO_TAG_GIVEN = 'No tag name supplied'
|
|
ERROR_TAG_TOO_SHORT = 'Not enough valid chars'
|
|
ERROR_SYNONYM_ITSELF = 'Cant apply synonym to itself'
|
|
ERROR_NO_SUCH_TAG = 'Doesn\'t exist'
|
|
|
|
####################################################################################################
|
|
####################################################################################################
|
|
####################################################################################################
|
|
####################################################################################################
|
|
|
|
def give_session_token(function):
|
|
@functools.wraps(function)
|
|
def wrapped(*args, **kwargs):
|
|
# Inject new token so the function doesn't know the difference
|
|
token = request.cookies.get('etiquette_session', None)
|
|
if not token:
|
|
token = generate_session_token()
|
|
request.cookies = dict(request.cookies)
|
|
request.cookies['etiquette_session'] = token
|
|
|
|
ret = function(*args, **kwargs)
|
|
|
|
# Send the token back to the client
|
|
if not isinstance(ret, flask.Response):
|
|
ret = flask.Response(ret)
|
|
ret.set_cookie('etiquette_session', value=token, max_age=60)
|
|
|
|
return ret
|
|
return wrapped
|
|
|
|
def _helper_comma_split(s):
|
|
if s is None:
|
|
return s
|
|
s = s.replace(' ', ',')
|
|
s = [x.strip() for x in s.split(',')]
|
|
s = [x for x in s if x]
|
|
return s
|
|
|
|
def create_tag(easybake_string):
|
|
notes = P.easybake(easybake_string)
|
|
notes = [{'action': action, 'tagname': tagname} for (action, tagname) in notes]
|
|
return notes
|
|
|
|
def delete_tag(tag):
|
|
tag = tag.split('.')[-1].split('+')[0]
|
|
tag = P.get_tag(tag)
|
|
|
|
tag.delete()
|
|
return {'action': 'delete_tag', 'tagname': tag.name}
|
|
|
|
def delete_synonym(synonym):
|
|
synonym = synonym.split('+')[-1].split('.')[-1]
|
|
synonym = phototagger.normalize_tagname(synonym)
|
|
try:
|
|
master_tag = P.get_tag(synonym)
|
|
except phototagger.NoSuchTag:
|
|
flask.abort(404, 'That synonym doesnt exist')
|
|
|
|
if synonym not in master_tag.synonyms():
|
|
flask.abort(400, 'That name is not a synonym')
|
|
|
|
master_tag.remove_synonym(synonym)
|
|
return {'action':'delete_synonym', 'synonym': synonym}
|
|
|
|
def edit_params(original, modifications):
|
|
new_params = original.to_dict()
|
|
new_params.update(modifications)
|
|
if not new_params:
|
|
return ''
|
|
new_params = ['%s=%s' % (k, v) for (k, v) in new_params.items() if v]
|
|
new_params = '&'.join(new_params)
|
|
new_params = '?' + new_params
|
|
return new_params
|
|
|
|
def generate_session_token():
|
|
token = str(uuid.uuid4())
|
|
#print('MAKE SESSION', token)
|
|
return token
|
|
|
|
def make_json_response(j, *args, **kwargs):
|
|
dumped = json.dumps(j)
|
|
response = flask.Response(dumped, *args, **kwargs)
|
|
response.headers['Content-Type'] = 'application/json;charset=utf-8'
|
|
return response
|
|
|
|
def P_album(albumid):
|
|
try:
|
|
return P.get_album(albumid)
|
|
except phototagger.NoSuchAlbum:
|
|
flask.abort(404, 'That tag doesnt exist')
|
|
|
|
def P_photo(photoid):
|
|
try:
|
|
return P.get_photo(photoid)
|
|
except phototagger.NoSuchPhoto:
|
|
flask.abort(404, 'That photo doesnt exist')
|
|
|
|
def P_tag(tagname):
|
|
try:
|
|
return P.get_tag(tagname)
|
|
except phototagger.NoSuchTag as e:
|
|
flask.abort(404, 'That tag doesnt exist: %s' % e)
|
|
|
|
def read_filebytes(filepath, range_min, range_max):
|
|
range_span = range_max - range_min
|
|
|
|
#print('read span', range_min, range_max, range_span)
|
|
f = open(filepath, 'rb')
|
|
f.seek(range_min)
|
|
sent_amount = 0
|
|
with f:
|
|
while sent_amount < range_span:
|
|
#print(sent_amount)
|
|
chunk = f.read(FILE_READ_CHUNK)
|
|
if len(chunk) == 0:
|
|
break
|
|
|
|
yield chunk
|
|
sent_amount += len(chunk)
|
|
|
|
def seconds_to_hms(seconds):
|
|
seconds = math.ceil(seconds)
|
|
(minutes, seconds) = divmod(seconds, 60)
|
|
(hours, minutes) = divmod(minutes, 60)
|
|
parts = []
|
|
if hours: parts.append(hours)
|
|
if minutes: parts.append(minutes)
|
|
parts.append(seconds)
|
|
hms = ':'.join('%02d' % part for part in parts)
|
|
return hms
|
|
|
|
def send_file(filepath):
|
|
'''
|
|
Range-enabled file sending.
|
|
'''
|
|
try:
|
|
file_size = os.path.getsize(filepath)
|
|
except FileNotFoundError:
|
|
flask.abort(404)
|
|
|
|
outgoing_headers = {}
|
|
mimetype = mimetypes.guess_type(filepath)[0]
|
|
if mimetype is not None:
|
|
if 'text/' in mimetype:
|
|
mimetype += '; charset=utf-8'
|
|
outgoing_headers['Content-Type'] = mimetype
|
|
|
|
if 'range' in request.headers:
|
|
desired_range = request.headers['range'].lower()
|
|
desired_range = desired_range.split('bytes=')[-1]
|
|
|
|
int_helper = lambda x: int(x) if x.isdigit() else None
|
|
if '-' in desired_range:
|
|
(desired_min, desired_max) = desired_range.split('-')
|
|
range_min = int_helper(desired_min)
|
|
range_max = int_helper(desired_max)
|
|
else:
|
|
range_min = int_helper(desired_range)
|
|
|
|
if range_min is None:
|
|
range_min = 0
|
|
if range_max is None:
|
|
range_max = file_size
|
|
|
|
# because ranges are 0-indexed
|
|
range_max = min(range_max, file_size - 1)
|
|
range_min = max(range_min, 0)
|
|
|
|
range_header = 'bytes {min}-{max}/{outof}'.format(
|
|
min=range_min,
|
|
max=range_max,
|
|
outof=file_size,
|
|
)
|
|
outgoing_headers['Content-Range'] = range_header
|
|
status = 206
|
|
else:
|
|
range_max = file_size - 1
|
|
range_min = 0
|
|
status = 200
|
|
|
|
outgoing_headers['Accept-Ranges'] = 'bytes'
|
|
outgoing_headers['Content-Length'] = (range_max - range_min) + 1
|
|
|
|
if request.method == 'HEAD':
|
|
outgoing_data = bytes()
|
|
else:
|
|
outgoing_data = read_filebytes(filepath, range_min=range_min, range_max=range_max)
|
|
|
|
response = flask.Response(
|
|
outgoing_data,
|
|
status=status,
|
|
headers=outgoing_headers,
|
|
)
|
|
return response
|
|
|
|
def truthystring(s):
|
|
if isinstance(s, (bool, int)) or s is None:
|
|
return s
|
|
s = s.lower()
|
|
if s in {'1', 'true', 't', 'yes', 'y', 'on'}:
|
|
return True
|
|
if s in {'null', 'none'}:
|
|
return None
|
|
return False
|
|
|
|
####################################################################################################
|
|
####################################################################################################
|
|
####################################################################################################
|
|
####################################################################################################
|
|
|
|
def jsonify_album(album, minimal=False):
|
|
j = {
|
|
'id': album.id,
|
|
'description': album.description,
|
|
'title': album.title,
|
|
}
|
|
if minimal is False:
|
|
j['photos'] = [jsonify_photo(photo) for photo in album.photos()]
|
|
j['parent'] = album.parent()
|
|
j['sub_albums'] = [child.id for child in album.children()]
|
|
|
|
return j
|
|
|
|
def jsonify_photo(photo):
|
|
tags = photo.tags()
|
|
tags.sort(key=lambda x: x.name)
|
|
j = {
|
|
'id': photo.id,
|
|
'extension': photo.extension,
|
|
'width': photo.width,
|
|
'height': photo.height,
|
|
'ratio': photo.ratio,
|
|
'area': photo.area,
|
|
'bytes': photo.bytes,
|
|
'duration': seconds_to_hms(photo.duration) if photo.duration is not None else None,
|
|
'duration_int': photo.duration,
|
|
'bytestring': photo.bytestring(),
|
|
'has_thumbnail': bool(photo.thumbnail),
|
|
'created': photo.created,
|
|
'filename': photo.basename,
|
|
'mimetype': photo.mimetype(),
|
|
'albums': [jsonify_album(album, minimal=True) for album in photo.albums()],
|
|
'tags': [jsonify_tag(tag) for tag in tags],
|
|
}
|
|
return j
|
|
|
|
def jsonify_tag(tag):
|
|
j = {
|
|
'id': tag.id,
|
|
'name': tag.name,
|
|
'qualified_name': tag.qualified_name(),
|
|
}
|
|
return j
|
|
|
|
####################################################################################################
|
|
####################################################################################################
|
|
####################################################################################################
|
|
####################################################################################################
|
|
|
|
@site.route('/')
|
|
@give_session_token
|
|
def root():
|
|
motd = random.choice(MOTD_STRINGS)
|
|
return flask.render_template('root.html', motd=motd)
|
|
|
|
@site.route('/favicon.ico')
|
|
@site.route('/favicon.png')
|
|
def favicon():
|
|
filename = os.path.join('static', 'favicon.png')
|
|
return flask.send_file(filename)
|
|
|
|
def get_album_core(albumid):
|
|
album = P_album(albumid)
|
|
album = jsonify_album(album)
|
|
return album
|
|
|
|
@site.route('/album/<albumid>')
|
|
@give_session_token
|
|
def get_album_html(albumid):
|
|
album = get_album_core(albumid)
|
|
response = flask.render_template(
|
|
'album.html',
|
|
album=album,
|
|
child_albums=[jsonify_album(P_album(x)) for x in album['sub_albums']],
|
|
photos=album['photos'],
|
|
)
|
|
return response
|
|
|
|
@site.route('/album/<albumid>.json')
|
|
@give_session_token
|
|
def get_album_json(albumid):
|
|
album = get_album_core(albumid)
|
|
return make_json_response(album)
|
|
|
|
@site.route('/albums')
|
|
@give_session_token
|
|
def get_albums_html():
|
|
albums = P.get_albums()
|
|
albums = [a for a in albums if a.parent() is None]
|
|
return flask.render_template('albums.html', albums=albums)
|
|
|
|
@site.route('/albums.json')
|
|
@give_session_token
|
|
def get_albums_json():
|
|
albums = P.get_albums()
|
|
albums = [a for a in albums if a.parent() is None]
|
|
albums = [jsonify_album(album, minimal=True) for album in albums]
|
|
return make_json_response(albums)
|
|
|
|
@site.route('/file/<photoid>')
|
|
def get_file(photoid):
|
|
requested_photoid = photoid
|
|
photoid = photoid.split('.')[0]
|
|
photo = P.get_photo(photoid)
|
|
|
|
do_download = request.args.get('download', False)
|
|
do_download = truthystring(do_download)
|
|
|
|
use_original_filename = request.args.get('original_filename', False)
|
|
use_original_filename = truthystring(use_original_filename)
|
|
|
|
if do_download:
|
|
if use_original_filename:
|
|
download_as = photo.basename
|
|
else:
|
|
download_as = photo.id + '.' + photo.extension
|
|
|
|
## Sorry, but otherwise the attachment filename gets terminated
|
|
#download_as = download_as.replace(';', '-')
|
|
download_as = download_as.replace('"', '\\"')
|
|
response = flask.make_response(send_file(photo.real_filepath))
|
|
response.headers['Content-Disposition'] = 'attachment; filename="%s"' % download_as
|
|
return response
|
|
else:
|
|
return send_file(photo.real_filepath)
|
|
|
|
def get_photo_core(photoid):
|
|
photo = P_photo(photoid)
|
|
photo = jsonify_photo(photo)
|
|
return photo
|
|
|
|
@site.route('/photo/<photoid>', methods=['GET'])
|
|
@give_session_token
|
|
def get_photo_html(photoid):
|
|
photo = get_photo_core(photoid)
|
|
photo['tags'].sort(key=lambda x: x['qualified_name'])
|
|
return flask.render_template('photo.html', photo=photo)
|
|
|
|
@site.route('/photo/<photoid>.json', methods=['GET'])
|
|
@give_session_token
|
|
def get_photo_json(photoid):
|
|
photo = get_photo_core(photoid)
|
|
photo = make_json_response(photo)
|
|
return photo
|
|
|
|
def get_search_core():
|
|
print(request.args)
|
|
|
|
# FILENAME & EXTENSION
|
|
filename_terms = request.args.get('filename', None)
|
|
extension_string = request.args.get('extension', None)
|
|
extension_not_string = request.args.get('extension_not', None)
|
|
mimetype_string = request.args.get('mimetype', None)
|
|
|
|
extension_list = _helper_comma_split(extension_string)
|
|
extension_not_list = _helper_comma_split(extension_not_string)
|
|
mimetype_list = _helper_comma_split(mimetype_string)
|
|
|
|
# LIMIT
|
|
limit = request.args.get('limit', '')
|
|
if limit.isdigit():
|
|
limit = int(limit)
|
|
limit = min(100, limit)
|
|
else:
|
|
limit = 50
|
|
|
|
# OFFSET
|
|
offset = request.args.get('offset', None)
|
|
if offset:
|
|
offset = int(offset)
|
|
else:
|
|
offset = None
|
|
|
|
# MUSTS, MAYS, FORBIDS
|
|
qualname_map = P.export_tags(exporter=phototagger.tag_export_qualname_map)
|
|
tag_musts = request.args.get('tag_musts', '').split(',')
|
|
tag_mays = request.args.get('tag_mays', '').split(',')
|
|
tag_forbids = request.args.get('tag_forbids', '').split(',')
|
|
tag_expression = request.args.get('tag_expression', None)
|
|
|
|
tag_musts = [qualname_map.get(tag, tag) for tag in tag_musts if tag != '']
|
|
tag_mays = [qualname_map.get(tag, tag) for tag in tag_mays if tag != '']
|
|
tag_forbids = [qualname_map.get(tag, tag) for tag in tag_forbids if tag != '']
|
|
|
|
# ORDERBY
|
|
orderby = request.args.get('orderby', None)
|
|
if orderby:
|
|
orderby = orderby.replace('-', ' ')
|
|
orderby = orderby.replace('_', ' ')
|
|
orderby = orderby.split(',')
|
|
else:
|
|
orderby = None
|
|
|
|
# HAS_TAGS
|
|
has_tags = request.args.get('has_tags', '')
|
|
if has_tags == '':
|
|
has_tags = None
|
|
else:
|
|
has_tags = truthystring(has_tags)
|
|
|
|
# MINMAXERS
|
|
area = request.args.get('area', None)
|
|
width = request.args.get('width', None)
|
|
height = request.args.get('height', None)
|
|
ratio = request.args.get('ratio', None)
|
|
bytes = request.args.get('bytes', None)
|
|
duration = request.args.get('duration', None)
|
|
created = request.args.get('created', None)
|
|
|
|
# These are in a dictionary so I can pass them to the page template.
|
|
search_kwargs = {
|
|
'area': area,
|
|
'width': width,
|
|
'height': height,
|
|
'ratio': ratio,
|
|
'bytes': bytes,
|
|
'duration': duration,
|
|
|
|
'created': created,
|
|
'extension': extension_list,
|
|
'extension_not': extension_not_list,
|
|
'filename': filename_terms,
|
|
'has_tags': has_tags,
|
|
'mimetype': mimetype_list,
|
|
'tag_musts': tag_musts,
|
|
'tag_mays': tag_mays,
|
|
'tag_forbids': tag_forbids,
|
|
'tag_expression': tag_expression,
|
|
|
|
'limit': limit,
|
|
'offset': offset,
|
|
'orderby': orderby,
|
|
|
|
'warn_bad_tags': True,
|
|
}
|
|
print(search_kwargs)
|
|
with warnings.catch_warnings(record=True) as catcher:
|
|
photos = list(P.search(**search_kwargs))
|
|
photos = [jsonify_photo(photo) for photo in photos]
|
|
warns = [str(warning.message) for warning in catcher]
|
|
#print(warns)
|
|
|
|
# TAGS ON THIS PAGE
|
|
total_tags = set()
|
|
for photo in photos:
|
|
for tag in photo['tags']:
|
|
total_tags.add(tag['qualified_name'])
|
|
total_tags = sorted(total_tags)
|
|
|
|
# PREV-NEXT PAGE URLS
|
|
offset = offset or 0
|
|
if len(photos) == limit:
|
|
next_params = edit_params(request.args, {'offset': offset + limit})
|
|
next_page_url = '/search' + next_params
|
|
else:
|
|
next_page_url = None
|
|
if offset > 0:
|
|
prev_params = edit_params(request.args, {'offset': max(0, offset - limit)})
|
|
prev_page_url = '/search' + prev_params
|
|
else:
|
|
prev_page_url = None
|
|
|
|
search_kwargs['extension'] = extension_string
|
|
search_kwargs['extension_not'] = extension_not_string
|
|
search_kwargs['mimetype'] = mimetype_string
|
|
|
|
final_results = {
|
|
'next_page_url': next_page_url,
|
|
'prev_page_url': prev_page_url,
|
|
'photos': photos,
|
|
'total_tags': total_tags,
|
|
'warns': warns,
|
|
'search_kwargs': search_kwargs,
|
|
'qualname_map': qualname_map,
|
|
}
|
|
return final_results
|
|
|
|
@site.route('/search')
|
|
@give_session_token
|
|
def get_search_html():
|
|
search_results = get_search_core()
|
|
search_kwargs = search_results['search_kwargs']
|
|
qualname_map = search_results['qualname_map']
|
|
response = flask.render_template(
|
|
'search.html',
|
|
next_page_url=search_results['next_page_url'],
|
|
prev_page_url=search_results['prev_page_url'],
|
|
photos=search_results['photos'],
|
|
qualname_map=json.dumps(qualname_map),
|
|
search_kwargs=search_kwargs,
|
|
total_tags=search_results['total_tags'],
|
|
warns=search_results['warns'],
|
|
)
|
|
return response
|
|
|
|
@site.route('/search.json')
|
|
@give_session_token
|
|
def get_search_json():
|
|
search_results = get_search_core()
|
|
search_kwargs = search_results['search_kwargs']
|
|
qualname_map = search_results['qualname_map']
|
|
include_qualname_map = request.args.get('include_map', False)
|
|
include_qualname_map = truthystring(include_qualname_map)
|
|
if not include_qualname_map:
|
|
search_results.pop('qualname_map')
|
|
return make_json_response(j)
|
|
|
|
@site.route('/static/<filename>')
|
|
def get_static(filename):
|
|
filename = filename.replace('\\', os.sep)
|
|
filename = filename.replace('/', os.sep)
|
|
filename = os.path.join('static', filename)
|
|
return flask.send_file(filename)
|
|
|
|
@site.route('/tags')
|
|
@site.route('/tags/<specific_tag>')
|
|
@give_session_token
|
|
def get_tags(specific_tag=None):
|
|
try:
|
|
tags = P.export_tags(phototagger.tag_export_easybake, specific_tag=specific_tag)
|
|
except phototagger.NoSuchTag:
|
|
flask.abort(404, 'That tag doesnt exist')
|
|
|
|
tags = tags.split('\n')
|
|
tags = [t for t in tags if t != '']
|
|
tags = [(t, t.split('.')[-1].split('+')[0]) for t in tags]
|
|
return flask.render_template('tags.html', tags=tags)
|
|
|
|
@site.route('/thumbnail/<photoid>')
|
|
def get_thumbnail(photoid):
|
|
photoid = photoid.split('.')[0]
|
|
photo = P_photo(photoid)
|
|
if photo.thumbnail:
|
|
path = photo.thumbnail
|
|
else:
|
|
flask.abort(404, 'That file doesnt have a thumbnail')
|
|
return send_file(path)
|
|
|
|
@site.route('/album/<albumid>', methods=['POST'])
|
|
@site.route('/album/<albumid>.json', methods=['POST'])
|
|
@give_session_token
|
|
def post_edit_album(albumid):
|
|
'''
|
|
Edit the album's title and description.
|
|
Apply a tag to every photo in the album.
|
|
'''
|
|
response = {}
|
|
album = P_album(albumid)
|
|
|
|
if 'add_tag' in request.form:
|
|
action = 'add_tag'
|
|
|
|
tag = request.form[action].strip()
|
|
try:
|
|
tag = P_tag(tag)
|
|
except phototagger.NoSuchTag:
|
|
response = {'error': 'That tag doesnt exist', 'tagname': tag}
|
|
return make_json_response(response, status=404)
|
|
recursive = request.form.get('recursive', False)
|
|
recursive = truthystring(recursive)
|
|
album.add_tag_to_all(tag, nested_children=recursive)
|
|
response['action'] = action
|
|
response['tagname'] = tag.name
|
|
return make_json_response(response)
|
|
|
|
@site.route('/photo/<photoid>', methods=['POST'])
|
|
@site.route('/photo/<photoid>.json', methods=['POST'])
|
|
@give_session_token
|
|
def post_edit_photo(photoid):
|
|
'''
|
|
Add and remove tags from photos.
|
|
'''
|
|
response = {}
|
|
photo = P_photo(photoid)
|
|
|
|
if 'add_tag' in request.form:
|
|
action = 'add_tag'
|
|
method = photo.add_tag
|
|
elif 'remove_tag' in request.form:
|
|
action = 'remove_tag'
|
|
method = photo.remove_tag
|
|
else:
|
|
flask.abort(400, 'Invalid action')
|
|
|
|
tag = request.form[action].strip()
|
|
if tag == '':
|
|
flask.abort(400, 'No tag supplied')
|
|
|
|
try:
|
|
tag = P.get_tag(tag)
|
|
except phototagger.NoSuchTag:
|
|
response = {'error': 'That tag doesnt exist', 'tagname': tag}
|
|
return make_json_response(response, status=404)
|
|
|
|
method(tag)
|
|
response['action'] = action
|
|
#response['tagid'] = tag.id
|
|
response['tagname'] = tag.name
|
|
return make_json_response(response)
|
|
|
|
@site.route('/tags', methods=['POST'])
|
|
@give_session_token
|
|
def post_edit_tags():
|
|
'''
|
|
Create and delete tags and synonyms.
|
|
'''
|
|
print(request.form)
|
|
status = 200
|
|
if 'create_tag' in request.form:
|
|
action = 'create_tag'
|
|
method = create_tag
|
|
elif 'delete_tag_synonym' in request.form:
|
|
action = 'delete_tag_synonym'
|
|
method = delete_synonym
|
|
elif 'delete_tag' in request.form:
|
|
action = 'delete_tag'
|
|
method = delete_tag
|
|
else:
|
|
status = 400
|
|
response = {'error': ERROR_INVALID_ACTION}
|
|
|
|
if status == 200:
|
|
tag = request.form[action].strip()
|
|
if tag == '':
|
|
response = {'error': ERROR_NO_TAG_GIVEN}
|
|
status = 400
|
|
|
|
if status == 200:
|
|
# expect the worst
|
|
status = 400
|
|
try:
|
|
response = method(tag)
|
|
except phototagger.TagTooShort:
|
|
response = {'error': ERROR_TAG_TOO_SHORT, 'tagname': tag}
|
|
except phototagger.CantSynonymSelf:
|
|
response = {'error': ERROR_SYNONYM_ITSELF, 'tagname': tag}
|
|
except phototagger.NoSuchTag as e:
|
|
response = {'error': ERROR_NO_SUCH_TAG, 'tagname': tag}
|
|
except ValueError as e:
|
|
response = {'error': e.args[0], 'tagname': tag}
|
|
else:
|
|
status = 200
|
|
|
|
response = json.dumps(response)
|
|
response = flask.Response(response, status=status)
|
|
return response
|
|
|
|
|
|
if __name__ == '__main__':
|
|
site.run(threaded=True)
|