Update app.py

app.py

@@ -9,12 +9,8 @@ import cv2
 import base64
 import httpx
 import logging
-import traceback
 import boto3
 import base64
-import urllib.parse
-from google.cloud import firestore
-from google.oauth2 import service_account
 
 app = FastAPI()
 
@@ -40,8 +36,277 @@ class ImageData(BaseModel):
 class UnprocessedImage(BaseModel):
     sheetID: str
     s3Url: str
+
+@app.post("/redirect")
+async def redirect_to_google_apps_script(request: Request):
+    # Get the body of the incoming request
+    body = await request.body()
+
+    async with httpx.AsyncClient(timeout=300.0, follow_redirects=True) as client:  # Follow redirects
+        response = await client.post(
+            'https://script.google.com/macros/s/AKfycbw9_31pMwQVhJPezJ9qlMRCAamQKRREnun-tfT_TnS5TOwOVcfdgU1Y9xTpAv6bZuiKOA/exec',
+            data=body
+        )
+        if response.status_code != 200:
+            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
+            raise HTTPException(status_code=500, detail="Error from external API.")
+        return response.json()
+
+appsScriptsURL = 'https://script.google.com/macros/s/AKfycbw9_31pMwQVhJPezJ9qlMRCAamQKRREnun-tfT_TnS5TOwOVcfdgU1Y9xTpAv6bZuiKOA/exec'
+dezgo_api_key = 'DEZGO-AA84DEB300562DA089E56CEA6081AE7DB601EF2D3EE4C693910E1C25E59A4FF8023D4932'
+
+dezgo_headers = {
+    'X-Dezgo-Key': dezgo_api_key,
+}
+
+# update the google sheet with failure
+async def record_failure(s3_original_url, failed_task, sheetID):
+    body = {
+        "s3Url": s3_original_url,
+        "mode": "failed",
+        "message": failed_task,
+        "sheetID": sheetID,
+    }
+    async with httpx.AsyncClient(follow_redirects=True) as client:
+        response = await client.post(appsScriptsURL, json=body)
+        if response.status_code != 200:
+            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
+            raise HTTPException(status_code=500, detail="Error from external API.")
+
+async def post_to_google_apps_script(appsScriptsURL, body, s3_orginal_url):
+    async with httpx.AsyncClient(follow_redirects=True) as client:
+        response = await client.post(appsScriptsURL, json=body)
+        if response.status_code != 200:
+            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
+            await record_failure(s3_orginal_url, 'Failed to queue processed image.', body.sheetID)
+
+async def background_worker(sheeturl, image_contents, filename, content_type, appsScriptsURL):
+    sheetID = sheeturl.split('/')[-2]
+    image_data = {
+        'sheetID': sheetID,
+        'fileName': filename,
+        'mimeType': content_type
+    }
+
+    s3_client = boto3.client('s3')
+    bucket_name = 're-sheet'
+    object_name = sheetID + '/' + image_data['fileName']
+    cut_images = []
+    s3_orginal_url = f"https://{bucket_name}.s3.amazonaws.com/{object_name}"
+    masked_image = await detect_receipts(image_contents, s3_orginal_url, sheetID)
+    await cutting_image(masked_image, image_contents, cut_images, s3_orginal_url, sheetID)
     
+    queued = []
+    # save the processed image(s) to s3
+    if not cut_images:
+        await record_failure(s3_orginal_url, 'No valid receipts found.', sheetID)
+        return {"message": "No valid receipts found."}
+    else:
+        for i, base64_str in enumerate(cut_images, start=1):
+            image_bytes = base64.b64decode(base64_str)
+            object_name = f"{object_name}_processed_{i}.png"
+            response = s3_client.put_object(
+                Bucket=bucket_name,
+                Key=object_name,
+                Body=image_bytes,
+                ContentType='image/png'
+            )
+            status = response.get("ResponseMetadata", {}).get("HTTPStatusCode")
+            if status != 200:
+                await record_failure(s3_orginal_url, 'Failed to upload processed image to S3.', sheetID)
+                return {"message": "Failed to upload processed image to S3."}
+            # otherwise put it as queued
+            object_s3_url = f"https://{bucket_name}.s3.amazonaws.com/{object_name}"
+            queued.append(object_s3_url)
+            # queue the image to google apps script web app
+        body ={
+            "queued": queued,
+            "mode": "mobile",
+            "sheetID": sheetID,
+        }
+        
+        print(body)
+        logging.info(body)
+        await post_to_google_apps_script(appsScriptsURL, body, s3_orginal_url)
+        return {"message": "Image processing completed."}
     
+# receive a sheetID and an image as multipart form data
+@app.post('/mobile-process-receipts')
+async def mobile_process_receipts(background_tasks: BackgroundTasks, sheeturl: str = Form(...),  image: UploadFile = File(...)):
+    image_contents = await image.read()
+    uuid = str(uuid4())
+    timestamp = str(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+    sheetID = sheeturl.split('/')[-2]
+    
+    message = "영수기 AI가 데이터 분석 중입니다. 잠시만 기다려주세요."
+    data = [timestamp, uuid, message]
+    body = {
+        "sheetID": sheetID,
+        "data": data,
+        "mode": "alert-user"
+    }
+    async with httpx.AsyncClient(follow_redirects=True) as client:
+        response = await client.post(appsScriptsURL, json=body)
+        if response.status_code != 200:
+            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
+            raise HTTPException(status_code=500, detail="Error from external API.")
+        
+    background_tasks.add_task(background_worker, sheeturl, image_contents, uuid, image.content_type, appsScriptsURL, )    
+
+    return {"message": "Image processing completed."}
+
+
+@app.post('/process-receipts')
+async def mobile_process_receipts(background_tasks: BackgroundTasks, request: Request):
+    data = await request.json()
+    base64_str = data['base64Image']
+    prefix, base64_str = base64_str.split(',', 1)  # Split on the first comma
+    image_contents = base64.b64decode(base64_str)
+    content_type = data['mimeType']
+    sheeturl = data['sheetID']
+    
+    checkPhoto = {
+        'sheetID': sheeturl.split('/')[-2],
+        'mode': "check",
+        'photo': image_contents,
+    }
+    async with httpx.AsyncClient(follow_redirects=True) as client:
+        response = await client.post(appsScriptsURL, json=checkPhoto)
+        if response.status_code != 200:
+            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
+            raise HTTPException(status_code=500, detail="Error from external API.")
+        if response.json()['status'] == 'invalid':
+            return {"message": "Invalid photo."}
+
+        
+    uuid = str(uuid4())
+    timestamp = str(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+    message = "영수기 AI가 데이터 분석 중입니다. 잠시만 기다려주세요."
+    data = [timestamp, uuid, message]
+    body = {
+        "sheetID": sheeturl.split('/')[-2],
+        "data": data,
+        "mode": "alert-user"
+    }
+    async with httpx.AsyncClient(follow_redirects=True) as client:
+        response = await client.post(appsScriptsURL, json=body)
+        if response.status_code != 200:
+            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
+            raise HTTPException(status_code=500, detail="Error from external API.")
+        
+    background_tasks.add_task(background_worker, sheeturl, image_contents, uuid, content_type, appsScriptsURL)    
+
+    return {"message": "Image processing completed."}
+    
+# send the image to dezgo
+async def detect_receipts(image_contents, s3_orginal_url, sheetID):
+    files = {
+        'image': ('filename', image_contents),
+        'mode': 'mask',
+    }
+    logging.info("Sending image to Dezgo API")
+    async with httpx.AsyncClient(timeout=timeout) as client:
+        response = await client.post('https://api.dezgo.com/remove-background', headers=dezgo_headers, files=files)
+        # if successful, pass the masked image to cutting_image function
+        if response.status_code == 200:
+            masked_image = response.content
+            return masked_image
+        else:
+            logging.error(f"Unexpected response from Dezgo API: {response.status_code} - {response.text}")
+            await record_failure(s3_orginal_url, 'Dezgo API failed.', sheetID)
+            raise HTTPException(status_code=500, detail="Error from external API.")
+
+# receive the masked image and process it
+async def cutting_image(masked_image, image_contents, cut_images, s3_orginal_url, sheetID):
+    # Convert the masked_image (which is in bytes format) to a numpy array. 
+    # The dtype of the array is set to np.uint8 because images are usually 8-bit per channel.
+    nparr_masked = np.frombuffer(masked_image, np.uint8)
+
+    # Check if the size of the numpy array is 0, which means that the conversion failed.
+    if nparr_masked.size == 0:
+        # Log an error message indicating that the conversion failed.
+        logging.error("Failed to convert API response to numpy array.")
+        # Record the reason for the failure.
+        record_failure(s3_orginal_url, 'failed to convert API response to numpy array.', sheetID)
+        # Raise an HTTPException with a 500 status code (Internal Server Error) and a detail message.
+        raise HTTPException(status_code=500, detail="Error processing API response data.")
+
+    # Decode the numpy array to an image using OpenCV. The flag cv2.IMREAD_COLOR loads the image in color.
+    masked_image = cv2.imdecode(nparr_masked, cv2.IMREAD_COLOR)
+
+    # Check if the decoding failed, which would result in masked_image being None.
+    if masked_image is None:
+        # Log an error message indicating that the decoding failed.
+        logging.error("Failed to decode image data.")
+        # Record the reason for the failure.
+        record_failure(s3_orginal_url, 'failed to decode image data.', sheetID)
+        # Raise an HTTPException with a 500 status code (Internal Server Error) and a detail message.
+        raise HTTPException(status_code=500, detail="Error decoding image data.")
+    
+    nparr_original = np.frombuffer(image_contents, np.uint8)
+    original_image = cv2.imdecode(nparr_original, cv2.IMREAD_COLOR)
+    
+    original_aspect_ratio = original_image.shape[1] / original_image.shape[0]
+    masked_aspect_ratio = masked_image.shape[1] / masked_image.shape[0]
+    
+    # if the image has been rotated by dezgo, rotate it back
+    if abs(original_aspect_ratio - masked_aspect_ratio) > 0.1: 
+        # Rotate the masked image 90 degrees clockwise
+        masked_image = cv2.rotate(masked_image, cv2.ROTATE_90_CLOCKWISE)
+    
+    original_image_shape = original_image.shape[:2]
+    
+    resized_masked_image = cv2.resize(masked_image, (original_image_shape[1], original_image_shape[0]))
+    
+
+
+    blurred_masked_image = cv2.GaussianBlur(resized_masked_image, (5, 5), 0)
+    _, thresh_masked_image = cv2.threshold(blurred_masked_image, 175, 255, cv2.THRESH_BINARY)
+    edges = cv2.Canny(thresh_masked_image, 75, 150)
+    contours, hierarchy = cv2.findContours(edges.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+    padding = 20
+    for contour in contours:
+        perimeter = cv2.arcLength(contour, True)
+        approximation = cv2.approxPolyDP(contour, 0.02 * perimeter, True)
+        x, y, w, h = cv2.boundingRect(approximation)
+
+        # Add padding to the bounding box coordinates while ensuring they are within the image boundaries
+        x_pad = max(x - padding, 0)
+        y_pad = max(y - padding, 0)
+        w_pad = min(w + 2 * padding, original_image.shape[1] - x_pad)
+        h_pad = min(h + 2 * padding, original_image.shape[0] - y_pad)
+        
+        # logging.info(f"Bounding box: x={x_pad}, y={y_pad}, w={w_pad}, h={h_pad}")
+
+        # Check if the area of the bounding rectangle is greater than 50px x 50px
+        if w_pad > 150 or h_pad > 150:
+            cropped_image = original_image[y_pad:y_pad + h_pad, x_pad:x_pad + w_pad]
+            _, img_encoded = cv2.imencode('.png', cropped_image)
+            base64_str = base64.b64encode(img_encoded).decode('utf-8')
+            cut_images.append(base64_str)
+
+
+@app.post('/test')
+async def mobile_process_receipts(background_tasks: BackgroundTasks, sheeturl: str = Form(...),  image: UploadFile = File(...)):
+    image_contents = await image.read()
+    uuid = str(uuid4())
+    timestamp = str(datetime.now().strftime("%Y-%m-%d-%H-%M-%S"))
+    message = "영수기가 데이터 분석 중입니다. 잠시만 기다려주세요."
+    data = [timestamp, uuid, message]
+    body = {
+        "sheetID": sheeturl.split('/')[-2],
+        "data": data,
+        "mode": "alert-user"
+    }
+    async with httpx.AsyncClient(follow_redirects=True) as client:
+        response = await client.post(appsScriptsURL, json=body)
+        if response.status_code != 200:
+            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
+            raise HTTPException(status_code=500, detail="Error from external API.")
+    background_tasks.add_task(background_worker, sheeturl, image_contents, image.filename, image.content_type, appsScriptsURL)    
+    return {"message": "Image processing completed."}
+
 # async def failure(sheetid):
 #     async with httpx.AsyncClient(follow_redirects=True) as client:
 #         response = await client.post(
@@ -102,21 +367,6 @@ class UnprocessedImage(BaseModel):
 #                 failure(image_data['sheetID'])
 #                 raise HTTPException(status_code=500, detail="Error from external API.")
 
-@app.post("/redirect")
-async def redirect_to_google_apps_script(request: Request):
-    # Get the body of the incoming request
-    body = await request.body()
-
-    async with httpx.AsyncClient(timeout=300.0, follow_redirects=True) as client:  # Follow redirects
-        response = await client.post(
-            'https://script.google.com/macros/s/AKfycbw9_31pMwQVhJPezJ9qlMRCAamQKRREnun-tfT_TnS5TOwOVcfdgU1Y9xTpAv6bZuiKOA/exec',
-            data=body
-        )
-        if response.status_code != 200:
-            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
-            raise HTTPException(status_code=500, detail="Error from external API.")
-        return response.json()
-
 # @app.post("/save-to-s3")
 # async def save_to_s3(request: Request, background_tasks: BackgroundTasks):
 #     image_data = await request.json()
@@ -335,256 +585,6 @@ async def redirect_to_google_apps_script(request: Request):
 
 #     finally:
 #         logging.info("File processing completed")
-
-
-
-
       
 # else:
-#         raise HTTPException(status_code=400, detail="Email address not provided.")
-appsScriptsURL = 'https://script.google.com/macros/s/AKfycbw9_31pMwQVhJPezJ9qlMRCAamQKRREnun-tfT_TnS5TOwOVcfdgU1Y9xTpAv6bZuiKOA/exec'
-dezgo_api_key = 'DEZGO-AA84DEB300562DA089E56CEA6081AE7DB601EF2D3EE4C693910E1C25E59A4FF8023D4932'
-
-dezgo_headers = {
-    'X-Dezgo-Key': dezgo_api_key,
-}
-
-# update the google sheet with failure
-async def record_failure(s3_original_url, failed_task, sheetID):
-    body = {
-        "s3Url": s3_original_url,
-        "mode": "failed",
-        "message": failed_task,
-        "sheetID": sheetID,
-    }
-    async with httpx.AsyncClient(follow_redirects=True) as client:
-        response = await client.post(appsScriptsURL, json=body)
-        if response.status_code != 200:
-            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
-            raise HTTPException(status_code=500, detail="Error from external API.")
-
-async def post_to_google_apps_script(appsScriptsURL, body, s3_orginal_url):
-    async with httpx.AsyncClient(follow_redirects=True) as client:
-        response = await client.post(appsScriptsURL, json=body)
-        if response.status_code != 200:
-            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
-            await record_failure(s3_orginal_url, 'Failed to queue processed image.', body.sheetID)
-
-async def background_worker(sheeturl, image_contents, filename, content_type, appsScriptsURL):
-    sheetID = sheeturl.split('/')[-2]
-    image_data = {
-        'sheetID': sheetID,
-        'fileName': filename,
-        'mimeType': content_type
-    }
-
-    s3_client = boto3.client('s3')
-    bucket_name = 're-sheet'
-    object_name = sheetID + '/' + image_data['fileName']
-    
-    s3response = s3_client.put_object(
-        Bucket=bucket_name, 
-        Key=object_name, 
-        Body=image_contents,
-        ContentType=image_data['mimeType']
-    )
-    cut_images = []
-    s3_orginal_url = f"https://{bucket_name}.s3.amazonaws.com/{object_name}"
-    masked_image = await detect_receipts(image_contents, s3_orginal_url, sheetID)
-    await cutting_image(masked_image, image_contents, cut_images, s3_orginal_url, sheetID)
-    
-    queued = []
-    # save the processed image(s) to s3
-    if not cut_images:
-        await record_failure(s3_orginal_url, 'No valid receipts found.', sheetID)
-        return {"message": "No valid receipts found."}
-    else:
-        for i, base64_str in enumerate(cut_images, start=1):
-            image_bytes = base64.b64decode(base64_str)
-            object_name = f"{object_name}_processed_{i}.png"
-            response = s3_client.put_object(
-                Bucket=bucket_name,
-                Key=object_name,
-                Body=image_bytes,
-                ContentType='image/png'
-            )
-            status = response.get("ResponseMetadata", {}).get("HTTPStatusCode")
-            if status != 200:
-                await record_failure(s3_orginal_url, 'Failed to upload processed image to S3.', sheetID)
-                return {"message": "Failed to upload processed image to S3."}
-            # otherwise put it as queued
-            object_s3_url = f"https://{bucket_name}.s3.amazonaws.com/{object_name}"
-            queued.append(object_s3_url)
-            # queue the image to google apps script web app
-        body ={
-            "queued": queued,
-            "mode": "mobile",
-            "sheetID": sheetID,
-        }
-        
-        print(body)
-        logging.info(body)
-        await post_to_google_apps_script(appsScriptsURL, body, s3_orginal_url)
-# receive a sheetID and an image as multipart form data
-@app.post('/mobile-process-receipts')
-async def mobile_process_receipts(background_tasks: BackgroundTasks, sheeturl: str = Form(...),  image: UploadFile = File(...)):
-    image_contents = await image.read()
-    uuid = str(uuid4())
-    timestamp = str(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
-    message = "영수기 AI가 데이터 분석 중입니다. 잠시만 기다려주세요."
-    data = [timestamp, uuid, message]
-    body = {
-        "sheetID": sheeturl.split('/')[-2],
-        "data": data,
-        "mode": "alert-user"
-    }
-    async with httpx.AsyncClient(follow_redirects=True) as client:
-        response = await client.post(appsScriptsURL, json=body)
-        if response.status_code != 200:
-            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
-            raise HTTPException(status_code=500, detail="Error from external API.")
-        
-    background_tasks.add_task(background_worker, sheeturl, image_contents, uuid, image.content_type, appsScriptsURL)    
-
-    return {"message": "Image processing completed."}
-
-@app.post('/process-receipts')
-async def mobile_process_receipts(background_tasks: BackgroundTasks, request: Request):
-    data = await request.json()
-    image_contents = base64.b64decode(data['base64Image'])
-    content_type = data['mimeType']
-    sheeturl = data['sheetID']
-    uuid = str(uuid4())
-    timestamp = str(datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
-    message = "영수기 AI가 데이터 분석 중입니다. 잠시만 기다려주세요."
-    data = [timestamp, uuid, message]
-    body = {
-        "sheetID": sheeturl.split('/')[-2],
-        "data": data,
-        "mode": "alert-user"
-    }
-    async with httpx.AsyncClient(follow_redirects=True) as client:
-        response = await client.post(appsScriptsURL, json=body)
-        if response.status_code != 200:
-            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
-            raise HTTPException(status_code=500, detail="Error from external API.")
-        
-    background_tasks.add_task(background_worker, sheeturl, image_contents, uuid, content_type, appsScriptsURL)    
-
-    return {"message": "Image processing completed."}
-    
-# send the image to dezgo
-async def detect_receipts(image_contents, s3_orginal_url, sheetID):
-    files = {
-        'image': ('filename', image_contents),
-        'mode': 'mask',
-    }
-    logging.info("Sending image to Dezgo API")
-    async with httpx.AsyncClient(timeout=timeout) as client:
-        response = await client.post('https://api.dezgo.com/remove-background', headers=dezgo_headers, files=files)
-        # if successful, pass the masked image to cutting_image function
-        if response.status_code == 200:
-            masked_image = response.content
-            return masked_image
-        else:
-            logging.error(f"Unexpected response from Dezgo API: {response.status_code} - {response.text}")
-            await record_failure(s3_orginal_url, 'Dezgo API failed.', sheetID)
-            raise HTTPException(status_code=500, detail="Error from external API.")
-
-# receive the masked image and process it
-async def cutting_image(masked_image, image_contents, cut_images, s3_orginal_url, sheetID):
-    # Convert the masked_image (which is in bytes format) to a numpy array. 
-    # The dtype of the array is set to np.uint8 because images are usually 8-bit per channel.
-    nparr_masked = np.frombuffer(masked_image, np.uint8)
-
-    # Check if the size of the numpy array is 0, which means that the conversion failed.
-    if nparr_masked.size == 0:
-        # Log an error message indicating that the conversion failed.
-        logging.error("Failed to convert API response to numpy array.")
-        # Record the reason for the failure.
-        record_failure(s3_orginal_url, 'failed to convert API response to numpy array.', sheetID)
-        # Raise an HTTPException with a 500 status code (Internal Server Error) and a detail message.
-        raise HTTPException(status_code=500, detail="Error processing API response data.")
-
-    # Decode the numpy array to an image using OpenCV. The flag cv2.IMREAD_COLOR loads the image in color.
-    masked_image = cv2.imdecode(nparr_masked, cv2.IMREAD_COLOR)
-
-    # Check if the decoding failed, which would result in masked_image being None.
-    if masked_image is None:
-        # Log an error message indicating that the decoding failed.
-        logging.error("Failed to decode image data.")
-        # Record the reason for the failure.
-        record_failure(s3_orginal_url, 'failed to decode image data.', sheetID)
-        # Raise an HTTPException with a 500 status code (Internal Server Error) and a detail message.
-        raise HTTPException(status_code=500, detail="Error decoding image data.")
-    
-    nparr_original = np.frombuffer(image_contents, np.uint8)
-    original_image = cv2.imdecode(nparr_original, cv2.IMREAD_COLOR)
-    
-    original_aspect_ratio = original_image.shape[1] / original_image.shape[0]
-    masked_aspect_ratio = masked_image.shape[1] / masked_image.shape[0]
-    
-    # if the image has been rotated by dezgo, rotate it back
-    if abs(original_aspect_ratio - masked_aspect_ratio) > 0.1: 
-        # Rotate the masked image 90 degrees clockwise
-        masked_image = cv2.rotate(masked_image, cv2.ROTATE_90_CLOCKWISE)
-    
-    original_image_shape = original_image.shape[:2]
-    
-    resized_masked_image = cv2.resize(masked_image, (original_image_shape[1], original_image_shape[0]))
-    
-
-
-    blurred_masked_image = cv2.GaussianBlur(resized_masked_image, (5, 5), 0)
-    _, thresh_masked_image = cv2.threshold(blurred_masked_image, 175, 255, cv2.THRESH_BINARY)
-    edges = cv2.Canny(thresh_masked_image, 75, 150)
-    contours, hierarchy = cv2.findContours(edges.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-
-    padding = 20
-    for contour in contours:
-        perimeter = cv2.arcLength(contour, True)
-        approximation = cv2.approxPolyDP(contour, 0.02 * perimeter, True)
-        x, y, w, h = cv2.boundingRect(approximation)
-
-        # Add padding to the bounding box coordinates while ensuring they are within the image boundaries
-        x_pad = max(x - padding, 0)
-        y_pad = max(y - padding, 0)
-        w_pad = min(w + 2 * padding, original_image.shape[1] - x_pad)
-        h_pad = min(h + 2 * padding, original_image.shape[0] - y_pad)
-        
-        # logging.info(f"Bounding box: x={x_pad}, y={y_pad}, w={w_pad}, h={h_pad}")
-
-        # Check if the area of the bounding rectangle is greater than 50px x 50px
-        if w_pad > 150 or h_pad > 150:
-            cropped_image = original_image[y_pad:y_pad + h_pad, x_pad:x_pad + w_pad]
-            _, img_encoded = cv2.imencode('.png', cropped_image)
-            base64_str = base64.b64encode(img_encoded).decode('utf-8')
-            cut_images.append(base64_str)
-# -> failed or empty: send a response of image and sheetid to the google sheet
-# save the processed image(s) to s3
-# -> failed or empty: send a response of image and sheetid to the google sheet
-# use google ocr to extract text from the image
-# -> failed or empty: send a response of image and sheetid to the google sheet
-# send the text to Openai
-# -> failed or empty: send a response of image and sheetid to the google sheet
-# send the response to the google sheet
-
-@app.post('/test')
-async def mobile_process_receipts(background_tasks: BackgroundTasks, sheeturl: str = Form(...),  image: UploadFile = File(...)):
-    image_contents = await image.read()
-    uuid = str(uuid4())
-    timestamp = str(datetime.now().strftime("%Y-%m-%d-%H-%M-%S"))
-    message = "영수기가 데이터 분석 중입니다. 잠시만 기다려주세요."
-    data = [timestamp, uuid, message]
-    body = {
-        "sheetID": sheeturl.split('/')[-2],
-        "data": data,
-        "mode": "alert-user"
-    }
-    async with httpx.AsyncClient(follow_redirects=True) as client:
-        response = await client.post(appsScriptsURL, json=body)
-        if response.status_code != 200:
-            logging.error(f"Unexpected response from Google Apps Script API: {response.status_code} - {response.text}")
-            raise HTTPException(status_code=500, detail="Error from external API.")
-    background_tasks.add_task(background_worker, sheeturl, image_contents, image.filename, image.content_type, appsScriptsURL)    
-    return {"message": "Image processing completed."}
+#         raise HTTPException(status_code=400, detail="Email address not provided.")