inference space trial

app.py

@@ -0,0 +1,124 @@
+import gradio as gr
+from pyzbar.pyzbar import decode
+from lambdas import upload_models, predict
+import base64
+from io import BytesIO
+from PIL import Image
+
+DEBUG = True
+
+prefer_frontal_cam_html = """
+<script>
+const originalGetUserMedia = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
+
+navigator.mediaDevices.getUserMedia = (constraints) => {
+  if (!constraints.video.facingMode) {
+    constraints.video.facingMode = {ideal: "environment"};
+  }
+  return originalGetUserMedia(constraints);
+};
+</script>
+"""
+
+config = {'possible_shifts': {'No shifts': 0}, 'possible_modes': ["waste"]}
+restaurant_id = None
+shift_id = None
+
+
+def login(username, password) -> bool:
+    # TODO from username and password get restaurant_id
+    config_aux = {'restaurant_id': 3,
+                  'restaurant_name': 'Proppos',
+                  'mode': 'waste',
+                  'possible_modes': ['waste'],
+                  'possible_shifts': {'Esmorzar': 1, 'Dinar': 2, 'Sopar': 3},
+                  }
+    config.update(config_aux)
+    return True
+
+
+def start_app(shift_id, mode):
+    try:
+        config_aux = {'shift_id': shift_id,
+                      'mode': mode}
+        config.update(config_aux)
+        gr.Info('Loading models', )
+        status_code, r = upload_models(**config)
+        if status_code in (201, 200, 204):
+            gr.Info('Models Correctly Loaded. Ready to predict')
+        else:
+            raise gr.Error(f'Error loading the models: {r}')
+        config.update(r)
+    except Exception as e:
+        raise gr.Error(f'Error Uploading the models. \n {e}')
+
+
+def predict_app(image, patient_id):
+    buffered = BytesIO()
+    image.save(buffered, format='JPEG')
+    b64image = base64.b64encode(buffered.getvalue()).decode('utf-8')
+    status_code, r = predict(b64image=b64image,
+                             patient_identifier=patient_id,
+                             **config)
+    if status_code in (200, 201, 204):
+        gr.Info('Prediction Successful')
+    else:
+        raise gr.Error(f'Error predicting {r}')
+
+
+# APP
+
+with gr.Blocks(head=prefer_frontal_cam_html) as block:
+    with gr.Tab(label='Welcome'):
+        gr.Markdown(f'# User: {config.get("restaurant_name", "Proppos")}')
+
+
+        @gr.render()
+        def render_dropdowns():
+            shift_dropdown = gr.Dropdown(label='Meal/Comida/Apat',
+                                         value=list(config["possible_shifts"].items())[0],
+                                         choices=tuple(config["possible_shifts"].items()))
+            mode_dropdown = gr.Dropdown(label='Mode',
+                                        value=config['possible_modes'][0],
+                                        choices=config["possible_modes"])
+            start_button = gr.Button(value='START')
+            start_button.click(fn=start_app, inputs=[shift_dropdown, mode_dropdown])
+
+    with gr.Tab(label='📷 Capture'):
+        # MAIN TAB TO PREDICT
+        gr.Markdown(f""" 1. Click to Access Webcam
+                         2.  
+                    """)
+        im = gr.Image(sources=['webcam'], streaming=True, mirror_webcam=False, type='pil')
+        with gr.Accordion():
+            eater_id = gr.Textbox(label='Patient Identification', placeholder='Searching Patient ID')
+
+        current_eater_id = {'value': None}
+
+
+        @gr.on(inputs=im, outputs=eater_id)
+        def search_eater_id(image):
+            d = decode(image)
+            default_value = None
+            current_value = current_eater_id['value'] or default_value
+            new_value = d[0].data if d else default_value
+            # If it is really a new value different from the default one, change it.
+            final_value = new_value if new_value != default_value else current_value
+            current_eater_id['value'] = final_value
+            return final_value
+
+
+        b = gr.Button('PRESS TO PREDICT')
+        b.click(fn=predict_app, inputs=[im, eater_id], outputs=gr.Info())
+
+    with gr.Tab(label='ℹ️ Status'):
+        gr.Markdown(' Press the button to see the status of the Application and technical information')
+        load_status_button = gr.Button('Load Status')
+        status_json = gr.Json(label='Status')
+        load_status_button.click(fn=lambda: config, outputs=status_json)
+
+    with gr.Tab(label='📄 Documentation'):
+        gr.Markdown()
+
+#block.launch(auth=("proppos", "Proppos2019"))
+block.launch(show_api=False, auth=login)

lambdas.py

@@ -0,0 +1,85 @@
+import os
+import boto3
+import json
+
+ACCESS_ID = os.environ.get('accessKeyId', None) or os.environ.get('AWS_ACCESS_KEY_ID', None)
+ACCESS_KEY = os.environ.get('secretAccessKey', None) or os.environ.get('AWS_SECRET_ACCESS_KEY', None)
+REGION = os.environ.get('region') or os.environ.get('AWS_REGION', None)
+
+lambda_client = boto3.client('lambda',
+                             region_name=REGION,
+                             aws_access_key_id=ACCESS_ID,
+                             aws_secret_access_key=ACCESS_KEY)
+
+
+def run_lambda(body, function_name, invocation_type='RequestResponse'):
+    response = json.load(lambda_client.invoke(FunctionName=function_name,
+                                              InvocationType=invocation_type,
+                                              Payload=json.dumps(body))['Payload'])
+
+    return response['statusCode'], json.loads(response['body']) if not isinstance(response['body'], dict) else response[
+        'body']
+
+
+def upload_models(
+        restaurant_id: int,
+        mode: str = 'waste',
+        shift_id: int = None,
+        what_to_load=None,
+        *args,
+        **kwargs,
+):
+    """
+    :param restaurant_id: int
+    :param mode: str
+    :param shift_id: int or None
+    :param what_to_load: dict of form {'od': bool, 'encoder': bool, 'decoder': bool}
+    :return: {"codes": codes,
+          "mode": mode,
+          "ip_ports": ip_ports,
+          "restaurant_id": restaurant_id,
+          "availability": availability,
+          "models_identifier": identifier,
+          "shift": event['shift_id'],
+          "references": references,
+          "models": models}
+    """
+
+    if what_to_load is None:
+        what_to_load = {'od': True, 'encoder': True, 'decoder': True}
+
+    body = {
+        'mode': mode,
+        'restaurant_id': restaurant_id,
+        'shift_id': shift_id,
+        'what_to_load': what_to_load,
+    }
+
+    status_code, r = run_lambda(body=body, function_name='postModels-fastpay-public-stack')
+
+    return status_code, r
+
+
+def predict(b64image: str,
+            ip_ports: dict,
+            upload: bool = True,
+            patient_identifier: bool = None,
+            codes: dict = None,
+            models_identifier: str = None,
+            shift: int = None,
+            *args,
+            **kwargs,
+            ):
+    body = {
+        "b64image": b64image,
+        "ip_ports": ip_ports,
+        "upload": upload,
+        "patient_identifier": '1', #None,  # patient_identifier
+        "codes": codes,
+        "models_identifier": models_identifier,
+        "shift": None  #shift,
+    }
+
+    status_code, r = run_lambda(body=body, function_name='getPredict-fastpay-public-stack')
+
+    return status_code, r

requirements.txt

@@ -0,0 +1,3 @@
+pyzbar
+pillow
+boto3