Update app.py

app.py

@@ -3,75 +3,78 @@ import subprocess
 import json
 import os
 import stat
+import requests
+import datetime
 import zipfile
-from PIL import ImageFont
 import matplotlib.font_manager
+from huggingface_hub import HfApi, HfFolder
 
-# Path to the compiled engine executable
+# Hugging Face repo and token
+HF_REPO = "ArrcttacsrjksX/Texttoimage"
+HF_ENGINE_URL = "https://huggingface.co/ArrcttacsrjksX/Texttoimage/resolve/main/engine"
+HF_TOKEN = os.getenv("HF_TOKEN")  # Lấy token từ biến môi trường
 ENGINE_EXECUTABLE = "./engine"
 
+def download_engine():
+    """Download engine from Hugging Face if not available."""
+    if not os.path.exists(ENGINE_EXECUTABLE):
+        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+        response = requests.get(HF_ENGINE_URL, headers=headers, stream=True)
+        if response.status_code == 200:
+            with open(ENGINE_EXECUTABLE, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            os.chmod(ENGINE_EXECUTABLE, os.stat(ENGINE_EXECUTABLE).st_mode | stat.S_IXUSR)
+        else:
+            raise Exception("Failed to download engine")
+
 def ensure_executable(file_path):
-    """
-    Đảm bảo rằng file có quyền thực thi.
-    Nếu không, cấp quyền thực thi.
-    """
-    if not os.access(file_path, os.X_OK):  # Kiểm tra quyền thực thi
-        try:
-            # Cấp quyền thực thi
-            current_permissions = os.stat(file_path).st_mode
-            os.chmod(file_path, current_permissions | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
-            print(f"Granted execute permission to {file_path}")
-        except Exception as e:
-            raise PermissionError(f"Failed to grant execute permission to {file_path}: {e}")
+    if not os.access(file_path, os.X_OK):
+        os.chmod(file_path, os.stat(file_path).st_mode | stat.S_IXUSR)
 
-def extract_and_load_fonts_from_directory(directory="fontfile", extract_to="extracted_fonts"):
+def extract_and_load_fonts(directory="fontfile", extract_to="extracted_fonts"):
     if not os.path.exists(extract_to):
         os.makedirs(extract_to)
-    
     fonts = []
-    
-    # Extract fonts from zip files
-    for root, dirs, files in os.walk(directory):
+    for root, _, files in os.walk(directory):
         for file in files:
             if file.endswith(".zip"):
                 zip_path = os.path.join(root, file)
                 try:
                     with zipfile.ZipFile(zip_path, 'r') as zip_ref:
                         zip_ref.extractall(extract_to)
-                    print(f"Extracted: {zip_path}")
                 except Exception as e:
                     print(f"Failed to extract {zip_path}: {e}")
-    
-    # Collect all .ttf and .shx fonts
-    for root, dirs, files in os.walk(extract_to):
+    for root, _, files in os.walk(extract_to):
         for file in files:
-            if file.endswith(".ttf") or file.endswith(".shx"):
+            if file.endswith(".ttf") or file.endswith(".otf") or file.endswith(".shx"):
                 fonts.append(os.path.join(root, file))
-    
     return fonts
 
 def get_system_fonts():
-    fonts = []
-    for font in matplotlib.font_manager.findSystemFonts(fontpaths=None, fontext='ttf'):
-        fonts.append(font)
-    return fonts
+    return matplotlib.font_manager.findSystemFonts(fontpaths=None, fontext='ttf')
 
 def get_available_fonts():
-    # Get system fonts
     system_fonts = get_system_fonts()
-    
-    # Extract and load custom fonts
-    extracted_fonts = extract_and_load_fonts_from_directory()
-    
-    # Combine and deduplicate fonts
-    all_fonts = list(set(system_fonts + extracted_fonts))
-    return sorted(all_fonts)
-
-def call_engine(input_text, font_size, width, height, bg_color, text_color, mode, font_name, align, line_spacing, image_format):
-    # Ensure the engine file is executable
+    extracted_fonts = extract_and_load_fonts()
+    return sorted(set(system_fonts + extracted_fonts))
+
+def upload_to_huggingface(file_path, text_content, timestamp_folder):
+    """Upload image and text to Hugging Face repo."""
+    api = HfApi()
+    HfFolder.save_token(HF_TOKEN)
+    repo_path = f"{HF_REPO}/{timestamp_folder}"
+    api.upload_file(path_or_fileobj=file_path, path_in_repo=f"{repo_path}/image.png", repo_id=HF_REPO)
+    with open("temp_text.txt", "w") as f:
+        f.write(text_content)
+    api.upload_file(path_or_fileobj="temp_text.txt", path_in_repo=f"{repo_path}/text.txt", repo_id=HF_REPO)
+    os.remove("temp_text.txt")
+
+def call_engine(file_input, input_text, font_size, width, height, bg_color, text_color, mode, font_name, align, line_spacing, image_format):
+    download_engine()
     ensure_executable(ENGINE_EXECUTABLE)
-
-    # Prepare input data as a dictionary
+    if file_input:
+        input_text = read_file_content(file_input)
     input_data = {
         "input_text": input_text,
         "font_size": font_size,
@@ -80,76 +83,58 @@ def call_engine(input_text, font_size, width, height, bg_color, text_color, mode
         "bg_color": bg_color,
         "text_color": text_color,
         "mode": mode,
-        "font_path": font_name,  # Pass the selected font path
+        "font_path": font_name,
         "align": align,
         "line_spacing": line_spacing,
         "image_format": image_format
     }
-
-    # Call the engine executable with input data
-    result = subprocess.run(
-        [ENGINE_EXECUTABLE, json.dumps(input_data)],
-        capture_output=True,
-        text=True
-    )
-
-    # Handle errors
+    result = subprocess.run([ENGINE_EXECUTABLE, json.dumps(input_data)], capture_output=True, text=True)
     if result.returncode != 0:
-        raise Exception(f"Engine failed with error: {result.stderr}")
-
-    # Get the output image path from stdout
+        raise Exception(f"Engine error: {result.stderr}")
     output_path = result.stdout.strip()
+    timestamp_folder = datetime.datetime.now().strftime("%d-%m-%Y %H-%M-%S")
+    upload_to_huggingface(output_path, input_text, timestamp_folder)
+    return output_path
 
-    # Load the generated image
-    if os.path.exists(output_path):
-        return output_path
-    else:
-        raise Exception("Failed to generate image!")
+def read_file_content(file):
+    """Read text from uploaded file."""
+    try:
+        return file.decode("utf-8") if isinstance(file, bytes) else file.read().decode("utf-8")
+    except Exception as e:
+        return f"Error reading file: {e}"
 
 with gr.Blocks() as demo:
     gr.Markdown("# 🖼️ Text to Image Converter")
-
+    available_fonts = get_available_fonts()
+    default_font = available_fonts[0] if available_fonts else ""
+    
     with gr.Row():
         input_text = gr.Textbox(label="Enter Text", placeholder="Type or paste text here...", lines=5)
-        file_input = gr.File(label="Upload a Text File", type="filepath")
-
+        file_input = gr.File(label="Upload a Text File", type="binary")
+    
     with gr.Row():
-        font_size = gr.Slider(10, 100, value=30, label="Font Size")
-        
-        # Lấy danh sách font và đặt font mặc định là font đầu tiên
-        available_fonts = get_available_fonts()
-        default_font = available_fonts[0] if available_fonts else ""
-        
+        font_size = gr.Slider(0, 100, value=30, label="Font Size")
         font_name = gr.Dropdown(choices=available_fonts, value=default_font, label="Font")
         align = gr.Radio(["Left", "Center", "Right"], label="Text Alignment", value="Center")
-
-    with gr.Row():
-        width = gr.Slider(200, 2000, value=800, label="Image Width")
-        height = gr.Slider(200, 2000, value=600, label="Base Height")
-
+        width = gr.Slider(0, 2000, value=800, label="Image Width")
+        height = gr.Slider(0, 2000, value=600, label="Image Height")
+    
     with gr.Row():
         bg_color = gr.ColorPicker(label="Background Color", value="#FFFFFF")
         text_color = gr.ColorPicker(label="Text Color", value="#000000")
-
+    
     with gr.Row():
         mode = gr.Radio(["Plain Text", "LaTeX Math"], label="Rendering Mode", value="Plain Text")
         image_format = gr.Radio(["PNG", "JPEG"], label="Image Format", value="PNG")
-
-    # Add line spacing slider
-    line_spacing = gr.Slider(1.0, 3.0, value=1.2, step=0.1, label="Line Spacing")
-
+    
+    line_spacing = gr.Slider(1.0, 10.0, value=1.2, step=0.1, label="Line Spacing")
     output_image = gr.Image(label="Generated Image")
-
-    with gr.Row():
-        convert_button = gr.Button("Convert Text to Image")
-        file_convert_button = gr.Button("Convert File to Image")
-
+    
+    convert_button = gr.Button("Convert Text to Image")
+    
     convert_button.click(
         call_engine,
-        inputs=[
-            input_text, font_size, width, height, bg_color, text_color,
-            mode, font_name, align, line_spacing, image_format
-        ],
+        inputs=[file_input, input_text, font_size, width, height, bg_color, text_color, mode, font_name, align, line_spacing, image_format],
         outputs=output_image
     )