sql name search many terms

4 files changed, 109 insertions, 148 deletions

diff --git a/megapixels/app/models/sql_factory.py b/megapixels/app/models/sql_factory.py
index a580f28e..82e59b22 100644
--- a/megapixels/app/models/sql_factory.py
+++ b/megapixels/app/models/sql_factory.py
@@ -101,10 +101,12 @@ class SqlDataset:
   def search_name(self, q):
     table = self.get_table('identity_meta')
     uuid_table = self.get_table('uuids')
+    identity_list = table.query.filter(table.fullname.like(q)).order_by(table.fullname.desc()).limit(10)
+    return identity_list
 
-    identity = table.query.filter(table.fullname.like(q)).order_by(table.fullname.desc()).limit(30)
+  def get_uuids_for_identities(self, identity_list):
     identities = []
-    for row in identity:
+    for row in identity_list:
       uuid = uuid_table.query.filter(uuid_table.id == row.image_id).first()
       identities.append({
         'uuid': uuid.toJSON(),
diff --git a/megapixels/app/server/api.py b/megapixels/app/server/api.py
index 3683d5fd..cc791bb2 100644
--- a/megapixels/app/server/api.py
+++ b/megapixels/app/server/api.py
@@ -3,6 +3,7 @@ import re
 import time
 import dlib
 import numpy as np
+import operator
 from flask import Blueprint, request, jsonify
 from PIL import Image  # todo: try to remove PIL dependency
 
@@ -139,14 +140,32 @@ def name_lookup(dataset_name):
   dataset = get_dataset(dataset_name)
 
   q = request.args.get('q')
+  q = re.sub('[^a-zA-Z ]+', '*', q)
+  terms = q.split(' ')
   # print(q)
 
   query = {
     'q': q,
     'timing': time.time() - start,
   }
-  results = dataset.search_name(q + '%') if q else None
-  
+  if len(terms) == 1:
+    names = dataset.search_name('%' + term + '%') if term else []
+    results = dataset.get_uuids_for_identities(names)
+  else:
+    lookup = {}
+    results_lookup = {}
+    for i, term in enumerate(terms):
+      search_term = '%' + term + '%'
+      names = dataset.search_name() if term else []
+      for name in names:
+        if name.id in lookup:
+          lookup[name.id] += 1
+        else:
+          lookup[name.id] = 1
+          results_lookup[name.id] = name
+    top_names = [results_lookup[item[0]] for item in sorted(lookup.items(), key=operator.itemgetter(1))][0:30]
+    results = dataset.get_uuids_for_identities(top_names)
+
   # print(results)
   return jsonify({
     'query': query,
diff --git a/megapixels/app/server/api_task.py b/megapixels/app/server/api_task.py
index acdb5b7d..36990997 100644
--- a/megapixels/app/server/api_task.py
+++ b/megapixels/app/server/api_task.py
@@ -13,175 +13,117 @@ from PIL import Image  # todo: try to remove PIL dependency
 
 from celery.result import AsyncResult
 from app.server.tasks import celery
+from app.server.tasks import task_lookup, list_active_tasks
 
 api_task = Blueprint('api_task', __name__)
 
 @api_task.route('/')
 def index():
-  """Dummy index"""
-  return jsonify({})
+  """List active tasks"""
+  return jsonify(list_active_tasks)
 
 # from flask import render_template, redirect, url_for, send_from_directory
 # from flask import request, make_response, jsonify
 # from . import main, utils
-from app.server.tasks import task_lookup, list_active_tasks
 # from PIL import Image, ImageOps
 # import cv2 as cv
-
 # import imutils
 
 @api_task.route('/<task_name>/<task_id>')
 def task_status(task_name, task_id):
-    """Return celery image processing status"""
-    if task_name in task_lookup:
-        task = task_lookup[task_name]['task'].AsyncResult(task_id)
-        # task = AsyncResult(task_id, app=celery)
-    else:
-        return jsonify({
-            'state': 'error',
-            'percent': 100,
-            'message': 'Unknown task'
-        })
+  """Return celery image processing status"""
+  if task_name in task_lookup:
+    task = task_lookup[task_name]['task'].AsyncResult(task_id)
+    # task = AsyncResult(task_id, app=celery)
+  else:
+    return jsonify({
+      'state': 'error',
+      'percent': 100,
+      'message': 'Unknown task'
+    })
 
-    # app.logger.info('task state: {}'.format(task.state))
-    if task.state == 'PENDING':
-        response = {
-            'state': task.state,
-            'percent': 0,
-            'message': 'Pending...'
-        }
-    elif task.state != 'FAILURE':
-        response = {
-            'state': task.state,
-            'percent': task.info.get('percent', 0),
-            'uuid': task.info.get('uuid', 0),
-            'message': task.info.get('message', '')
-        }
-        if 'result' in task.info:
-            response['result'] = task.info['result']
-    else:
-        # something went wrong in the background job
-        response = {
-            'state': task.state,
-            'percent': 100,
-            'message': str(task.info),  # this is the exception raised
-        }
-    return jsonify(response)
+  # app.logger.info('task state: {}'.format(task.state))
+  if task.state == 'PENDING':
+    response = {
+      'state': task.state,
+      'percent': 0,
+      'message': 'Pending...'
+    }
+  elif task.state != 'FAILURE':
+    response = {
+      'state': task.state,
+      'percent': task.info.get('percent', 0),
+      'uuid': task.info.get('uuid', 0),
+      'message': task.info.get('message', '')
+    }
+    if 'result' in task.info:
+      response['result'] = task.info['result']
+  else:
+    # something went wrong in the background job
+    response = {
+      'state': task.state,
+      'percent': 100,
+      'message': str(task.info),  # this is the exception raised
+    }
+  return jsonify(response)
 
 @api_task.route('/upload/sleep', methods=['GET', 'POST'])
 def sleep_test():
-    async_task = task_lookup['sleep']['task'].apply_async(args=['sleep_test'])
-    task_url = '/task/{}/{}'.format('sleep', async_task.id)
+  async_task = task_lookup['sleep']['task'].apply_async(args=['sleep_test'])
+  task_url = '/task/{}/{}'.format('sleep', async_task.id)
+  return jsonify({
+    'result': True,
+    'task_url': task_url,
+  })
+
+@api_task.route('/upload', methods=['POST'])
+def upload():
+  style = request.form['style']
+  print('style',style)
+  if style in task_lookup:
+    task = task_lookup[style]['task']
+    print('task',task)
+  else:
     return jsonify({
-        'result': True,
-        'task_url': task_url,
+      'result': False,
+      'error': 'Unknown task',
     })
 
-# @api_task.route('/upload', methods=['POST'])
-# def upload():
-
-#     style = request.form['style']
-#     print('style',style)
-#     if style in task_lookup:
-#         task = task_lookup[style]['task']
-#         print('task',task)
-#     else:
-#         return jsonify({
-#             'result': False,
-#             'error': 'Unknown task',
-#         })
-
-#     file = request.files['user_image']
-#     agree = bool(request.form['agree'])
-#     ext = request.form['ext']
-#     if ext is None:
-#         ext = request.files['ext']
-
-#     uuid_name = str(uuid.uuid4())
-
-#     app.logger.info('[+] style: {}'.format(style))
-#     app.logger.info('[+] ext: {}'.format(ext))
-#     app.logger.info('[+] uuid_name: {}'.format(uuid_name))
-#     app.logger.info('[+] agreed: {}'.format(agree))
-
-#     # convert PNG to JPG
-#     print('[+] Resizing image')
-
-#     # LOL MaskRCNN needs to be run outside of the Celery Task    
-#     im = Image.open(file.stream).convert('RGB')
-#     im = ImageOps.fit(im,(512,512))
-#     if agree:
-#         upload_folder = app.config['UPLOADS']
-#     else:
-#         upload_folder = app.config['UPLOADS_PRIVATE']
-
-#     fpath = os.path.join(upload_folder, uuid_name + '.jpg')
-
-#     # Save image to disk
-#     print('[+] Save image to {}'.format(fpath))
-#     im.save(fpath, 'JPEG', quality=100)
-#     im_pil_256 = im.resize((256,256))
+  file = request.files['user_image']
+  ext = request.form['ext']
+  if ext is None:
+    ext = request.files['ext']
 
-#     print('[+] ensure_np...')
-#     im_np = imx.ensure_np(im_pil_256)
-#     #print('[+] resize np...')
-#     #im_np = imutils.resize(im_np,width=256)
+  uuid_name = str(uuid.uuid4())
 
-#     upload_dir, render_dir, json_dir, upload_uri, render_uri = get_paths(agree)
+  app.logger.info('[+] style: {}'.format(style))
+  app.logger.info('[+] ext: {}'.format(ext))
+  app.logger.info('[+] uuid_name: {}'.format(uuid_name))
 
-#     print('[+] Run mrcnn...')
-#     try:
-#         result = mask_rcnn.create_segmentations(im_np,concat=True)
-#     except:
-#         print('[-] Error. Could not run mask_rcnn')
-#         result = []
+  # convert PNG to JPG
+  print('[+] Resizing image')
 
-#     if len(result) > 0:
-#         result = result[0]
+  # LOL MaskRCNN needs to be run outside of the Celery Task  
+  im = Image.open(file.stream).convert('RGB')
+  im = ImageOps.fit(im,(512,512))
 
-#         # save data, then pass to celery task
-#         print('[+] Save masks')
-#         seg_mask = result['seg_mask']
-#         fpath_seg_mask = os.path.join(render_dir, uuid_name + '_seg_mask.jpg')
-#         #cv.imwrite(fpath_seg_mask,cv.cvtColor(seg_mask,cv.COLOR_BGR2RGB))
-#         #seg_mask = seg_mask[:,:,::-1]
-#         seg_mask_pil = imx.ensure_pil(seg_mask)
-#         seg_mask_pil.save(fpath_seg_mask, 'JPEG', quality=100)
+  # # Save image to disk
+  # print('[+] Save image to {}'.format(fpath))
+  # im.save(fpath, 'JPEG', quality=100)
+  # im_pil_256 = im.resize((256,256))
 
-#         im_mask = result['im_mask']
-#         fpath_im_mask = os.path.join(render_dir, uuid_name + '_im_mask.jpg')
-#         #im_mask = im_mask[:,:,::-1]
-#         im_mask_pil = imx.ensure_pil(im_mask)
-#         im_mask_pil.save(fpath_im_mask, 'JPEG',quality=100)
-#         #cv.imwrite(fpath_im_mask,cv.cvtColor(im_mask,cv.COLOR_BGR2RGB))
+  print('[+] ensure_np...')
+  im_np = imx.ensure_np(im_pil_256)
 
-#         celery_result = {
-#             'score':str(result['score']),
-#             'name':str(result['name']),
-#             'class_index':str(result['class_index']),
-#             'color':str(result['color']),
-#             'fp_im_mask':fpath_im_mask,
-#             'fp_seg_mask':fpath_seg_mask,
-#             'valid':True
-#         }
-#     else:
-#         print('[-] no reults. process background only')
-#         celery_result = {
-#             'score':None,
-#             'name':None,
-#             'class_index':None,
-#             'color':None,
-#             'fp_im_mask':None,
-#             'fp_seg_mask':None,
-#             'valid':False
-#         }
+  celery_result = {
+  }
 
-#     print('[+] Start celery')
-#     async_task = task.apply_async(args=[uuid_name, agree, celery_result])
-#     task_url = url_for('main.task_status', task_name=style, task_id=async_task.id)
+  print('[+] Start celery')
+  async_task = task.apply_async(args=[uuid_name, celery_result])
+  task_url = '/task/{}/{}'.format(style, async_task.id)
 
-#     return jsonify({
-#         'result': True,
-#         'task_url': task_url,
-#         'uuid': uuid_name
-#     })
+  return jsonify({
+    'result': True,
+    'task_url': task_url,
+    'uuid': uuid_name
+  })
diff --git a/megapixels/app/server/tasks/blur.py b/megapixels/app/server/tasks/blur.py
index 508de477..ede75e6a 100644
--- a/megapixels/app/server/tasks/blur.py
+++ b/megapixels/app/server/tasks/blur.py
@@ -16,12 +16,10 @@ celery_logger = get_task_logger(__name__)
 import imutils
 
 @celery.task(bind=True)
-def blur_task(self, uuid_name, agree, extra):
+def blur_task(self, uuid_name, extra):
   """Process image and update during"""
   celery_logger.debug('process_image_task, uuid: {}'.format(uuid_name))
 
-  upload_dir, render_dir, json_dir, upload_uri, render_uri = get_paths(agree)
-
   files = []
 
   im = Image.open(os.path.join(upload_dir, uuid_name + '.jpg')).convert('RGB')