Update main.py

main.py

@@ -1,27 +1,28 @@
-import os
 import asyncio
+import os
+from enkacard import encbanner
 import concurrent.futures
 import requests
 from fastapi import FastAPI
 from io import BytesIO
-from enkacard import encbanner
 from fastapi.responses import JSONResponse
 import enkacard
-import starrailcard  # Import StarRailCard module
+import starrailcard
 import enkanetwork
 import uvicorn
-from fastapi.staticfiles import StaticFiles
+import cloudinary
+import cloudinary.uploader
+from cloudinary.utils import cloudinary_url
 
 app = FastAPI()
 
-# Directory where images will be saved
-IMAGE_SAVE_PATH = "static/cards"
-
-# Ensure the directory exists
-os.makedirs(IMAGE_SAVE_PATH, exist_ok=True)
-
-# Mount the static files directory to serve saved images
-app.mount("/cards", StaticFiles(directory=IMAGE_SAVE_PATH), name="cards")
+# Cloudinary configuration
+cloudinary.config(
+    cloud_name="dob6buqxd",
+    api_key="397945971979515",
+    api_secret="nRMIOSr10xiLo443LLMNDxJBB-Q",
+    secure=True
+)
 
 # Genshin Impact card creation
 async def genshin_card(id, designtype):
@@ -30,60 +31,14 @@ async def genshin_card(id, designtype):
 
 # Star Rail card creation
 async def starrail_card(id, designtype):
-    async with starrailcard.Card(seeleland=True, remove_logo=True, enka=True) as card:
+    async with starrailcard.Card(seeleland=True, remove_logo=True) as card:
         return await card.create(id, style=(2 if str(designtype) == "2" else 1))
 
 # Star Rail profile creation
 async def starrail_profile(id):
-    async with starrailcard.Card(remove_logo=True, seeleland=True, enka=True) as card:
+    async with starrailcard.Card(remove_logo=True, seeleland=True) as card:
         return await card.create_profile(id, style=2)
 
-# Helper function to save the image locally
-def save_image(data, file_name):
-    file_path = os.path.join(IMAGE_SAVE_PATH, file_name)
-    with open(file_path, "wb") as file:
-        file.write(data)
-    return f"/cards/{file_name}"
-
-# Process individual image card
-def process_image(dt, user_id):
-    file_name = f"{dt.id}_{user_id}.png"
-    with BytesIO() as byte_io:
-        dt.card.save(byte_io, "PNG")
-        byte_io.seek(0)
-        # Save the image locally
-        image_url = save_image(byte_io.read(), file_name)
-        return {
-            "name": dt.name,
-            "url": image_url
-        }
-
-# Process the profile image
-def process_profile(profile_card, user_id):
-    file_name = f"profile_{user_id}.png"
-    with BytesIO() as byte_io:
-        profile_card.card.save(byte_io, "PNG")
-        byte_io.seek(0)
-        # Save the profile image locally
-        image_url = save_image(byte_io.read(), file_name)
-        return {
-            "name": profile_card.character_name,
-            "url": image_url,
-            "character_ids": profile_card.character_id
-        }
-
-# Process all the images returned
-def process_images(result, user_id):
-    characters = []
-    with concurrent.futures.ThreadPoolExecutor() as executor:
-        futures = [executor.submit(process_image, dt, user_id) for dt in result.card]
-        for future in concurrent.futures.as_completed(futures):
-            try:
-                characters.append(future.result())
-            except Exception as e:
-                print(f"Error processing image: {e}")
-    return characters
-
 # Route for Genshin Impact
 @app.get("/genshin/{id}")
 async def genshin_characters(id: int, design: str = "1"):
@@ -123,6 +78,62 @@ async def starrail_profile_route(id: int):
     except Exception as e:
         return JSONResponse(content={'error': 'UNKNOWN ERR: ' + str(e)}, status_code=500)
 
-# Start the FastAPI server
+@app.get("/")
+def root():
+    return "Welcome to the API!"
+
+# Helper function to upload the image to Cloudinary
+def upload_image(data, character_id, player_id):
+    try:
+        # Set the public_id to include the character ID and the given player ID
+        public_id = f"{character_id}_{player_id}"
+
+        # Upload image to Cloudinary with the specified public_id
+        upload_result = cloudinary.uploader.upload(data, folder="card_images", public_id=public_id,invalidate = True)
+
+        # Get the secure URL of the uploaded image
+        return upload_result["secure_url"]
+    except Exception as e:
+        raise Exception(f"Cloudinary upload error: {str(e)}")
+
+# Process individual image card
+def process_image(dt, player_id):
+    with BytesIO() as byte_io:
+        dt.card.save(byte_io, "PNG")
+        byte_io.seek(0)
+        # Upload the image using the character's ID and player ID
+        image_url = upload_image(byte_io, dt.id, player_id)
+        return {
+            "name": dt.name,
+            "id": dt.id,
+            "url": image_url
+        }
+
+# Process the profile image
+def process_profile(profile_card, player_id):
+    with BytesIO() as byte_io:
+        profile_card.card.save(byte_io, "PNG")
+        byte_io.seek(0)
+        # Use the character ID and player ID for the profile card
+        image_url = upload_image(byte_io, profile_card.character_id, player_id)
+        return {
+            "name": profile_card.character_name,
+            "url": image_url,
+            "character_ids": profile_card.character_id
+        }
+
+# Process all the images returned
+def process_images(result, player_id):
+    characters = []
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = [executor.submit(process_image, dt, player_id) for dt in result.card]
+        for future in concurrent.futures.as_completed(futures):
+            try:
+                characters.append(future.result())
+            except Exception as e:
+                print(f"Error processing image: {e}")
+    return characters
+
 if __name__ == "__main__":
     uvicorn.run("main:app", host="0.0.0.0", port=7860, workers=8, timeout_keep_alive=60000)
+