Upload 25 files

src/firebase/firebase_provider.py

@@ -6,7 +6,7 @@ from PIL import Image
 import io
 import aiofiles
 import asyncio
-from typing import List
+from typing import List, Optional
 from datetime import datetime
 import pytz
 
@@ -14,14 +14,15 @@ import pytz
 import asyncio
 import functools
 
+
 def upload_file_to_storage_sync(file_path, file_name):
     """
     Synchronous function to upload a file to Firebase Storage.
-    
+
     param:
         file_path: str - The path of the file on the local machine to be uploaded.
         file_name: str - The name of the file in Firebase Storage.
-    
+
     return:
         str - The public URL of the uploaded file.
     """
@@ -31,26 +32,28 @@ def upload_file_to_storage_sync(file_path, file_name):
 
     return blob.public_url
 
+
 async def upload_file_to_storage(file_path: str, file_name: str) -> str:
     """
     Asynchronous wrapper to upload a file to Firebase Storage using a thread pool.
-    
+
     param:
         file_path: str - The path of the file on the local machine to be uploaded.
         file_name: str - The name of the file in Firebase Storage.
-    
+
     return:
         str - The public URL of the uploaded file.
     """
     loop = asyncio.get_event_loop()
 
     # Run the synchronous `upload_file_to_storage_sync` in a thread pool.
-    public_url = await loop.run_in_executor(None, functools.partial(upload_file_to_storage_sync, file_path, file_name))
+    public_url = await loop.run_in_executor(
+        None, functools.partial(upload_file_to_storage_sync, file_path, file_name)
+    )
 
     return public_url
 
 
-
 def delete_file_from_storage(file_name):
     """
     Delete a file from Firebase Storage
@@ -98,60 +101,76 @@ def download_file_from_storage(file_name, destination_path):
         return False
 
 
-async def upload_base64_image_to_storage(base64_image: str, file_name: str) -> str:
+async def upload_base64_image_to_storage(
+    base64_image: str, file_name: str
+) -> Optional[str]:
     """
-    Upload a base64 image to Firebase Storage.
-    
-    param:
-        base64_image: str - The base64 encoded image.
-        file_name: str - The name of the file to be uploaded.
-    
-    return:
-        str - The public URL of the uploaded file.
+    Upload a base64 image to Firebase Storage asynchronously.
+
+    Args:
+        base64_image: str - The base64 encoded image
+        file_name: str - The name of the file to be uploaded
+
+    Returns:
+        Optional[str] - The public URL of the uploaded file or None if failed
     """
     try:
-        # Decode the base64 image
-        image_data = base64.b64decode(base64_image)
+        # Run CPU-intensive operations in thread pool
+        loop = asyncio.get_event_loop()
+
+        # Decode base64 in thread pool
+        image_data = await loop.run_in_executor(
+            None, lambda: base64.b64decode(base64_image)
+        )
 
-        # Convert the decoded image to a JPG file
-        image = Image.open(io.BytesIO(image_data))
-        
-        # Generate a temporary file path
-        temp_file_path = f"{tempfile.gettempdir()}/{file_name}.jpg"
+        # Open and process image in thread pool
+        image = await loop.run_in_executor(
+            None, lambda: Image.open(io.BytesIO(image_data))
+        )
 
-        # Since image.save is a blocking operation, run it in a thread pool
-        loop = asyncio.get_event_loop()
-        await loop.run_in_executor(None, lambda: image.save(temp_file_path, format="JPEG"))
+        # Create unique temp file path
+        temp_file_path = os.path.join(
+            tempfile.gettempdir(), f"{file_name}_{datetime.now().timestamp()}.jpg"
+        )
 
-        # Upload the JPG file to Firebase Storage
-        public_url = await upload_file_to_storage(temp_file_path, f"{file_name}.jpg")
+        # Save image in thread pool
+        await loop.run_in_executor(
+            None, lambda: image.save(temp_file_path, format="JPEG")
+        )
 
-        # Remove the temporary file
-        os.remove(temp_file_path)
+        try:
+            # Upload to Firebase
+            public_url = await upload_file_to_storage(
+                temp_file_path, f"{file_name}.jpg"
+            )
+            return public_url
+        finally:
+            # Clean up temp file in thread pool
+            await loop.run_in_executor(None, os.remove, temp_file_path)
 
-        return public_url
     except Exception as e:
-        print("Error:", e)
+        print(f"Error processing image {file_name}: {str(e)}")
         return None
 
-async def process_images(base64_images: list) -> list:
+
+async def process_images(base64_images: List[str]) -> List[Optional[str]]:
+    """
+    Process multiple base64 images concurrently.
+
+    Args:
+        base64_images: List[str] - List of base64 encoded images
+
+    Returns:
+        List[Optional[str]] - List of public URLs or None for failed uploads
+    """
     tasks = []
     for idx, base64_image in enumerate(base64_images):
         timestamp = (
             datetime.now(pytz.timezone("Asia/Ho_Chi_Minh"))
             .replace(tzinfo=None)
-            .strftime("%Y-%m-%d %H:%M:%S")
+            .strftime("%Y-%m-%d_%H-%M-%S")
         )
-        encoded_timestamp = (
-            base64.urlsafe_b64encode(timestamp.encode()).decode().rstrip("=")
-        )
-        file_name = f"image_{encoded_timestamp}_{idx}"
+        file_name = f"image_{timestamp}_{idx}"
         tasks.append(upload_base64_image_to_storage(base64_image, file_name))
 
-    # Gather all async tasks
-    final_output = await asyncio.gather(*tasks)
-
-    # Check the output for debugging
-    print("final_output", final_output)  # Print the final output for debugging
-
-    return final_output
+    return await asyncio.gather(*tasks, return_exceptions=True)