Update app.py

app.py

@@ -1,142 +1,108 @@
+from flask import Flask, request, jsonify, send_file
+from flask.templating import render_template
 import os
 import threading
-import requests
-from flask import Flask, request, jsonify
-
-from llm import generate_llm
-from sd import generate_sd
-
-GREEN_API_URL = os.getenv("GREEN_API_URL")
-GREEN_API_MEDIA_URL = os.getenv("GREEN_API_MEDIA_URL", "https://api.green-api.com")
-GREEN_API_TOKEN = os.getenv("GREEN_API_TOKEN")
-GREEN_API_ID_INSTANCE = os.getenv("GREEN_API_ID_INSTANCE")
-WEBHOOK_AUTH_TOKEN = os.getenv("WEBHOOK_AUTH_TOKEN")
-PORT = 7860
-
-if not all([GREEN_API_URL, GREEN_API_TOKEN, GREEN_API_ID_INSTANCE, WEBHOOK_AUTH_TOKEN]):
-    raise ValueError("Environment variables are not set properly")
+import yaml
+from image_payload_reader import read_payload_from_image
+from telegram import start_telegram_bot
+from utils import read_config
 
 app = Flask(__name__)
-
-def send_message(message_id, to_number, message, retries=3):
-    """
-    Send a text message using Green API with retry logic.
-    """
-    if to_number.endswith('@g.us'):
-        chat_id = to_number
-    else:
-        chat_id = to_number
-
-    url = f"{GREEN_API_URL}/waInstance{GREEN_API_ID_INSTANCE}/sendMessage/{GREEN_API_TOKEN}"
-    payload = {
-        "chatId": chat_id,
-        "message": message,
-        "quotedMessageId": message_id,
+templates_dir = "templates"
+
+# Model for response
+class ImageFile:
+    def __init__(self, image, yaml_data):
+        self.image = image
+        self.yaml = yaml_data
+
+class ImageResponse:
+    def __init__(self, image_files):
+        self.image_files = image_files
+
+def refresh_info():
+    config = read_config()
+    app_version = config['app']['version']
+    whatsapp_bot_enabled = config['app']['whatsapp_bot_enabled']
+    telegram_bot_enabled = config['app']['telegram_bot_enabled']
+    info = {
+        'version': app_version,
+        'whatsapp_bot_enabled': whatsapp_bot_enabled,
+        'telegram_bot_enabled': telegram_bot_enabled,
     }
-
-    for attempt in range(retries):
-        try:
-            response = requests.post(url, json=payload)
-            response.raise_for_status()
-            return response.json()
-        except requests.RequestException as e:
-            if attempt < retries - 1:
-                continue
-            return {"error": str(e)}
-
-def send_image(message_id, to_number, image_path, retries=3):
-    """
-    Send an image using Green API with retry logic.
-    """
-    if to_number.endswith('@g.us'):
-        chat_id = to_number
-    else:
-        chat_id = to_number
-
-    url = f"{GREEN_API_MEDIA_URL}/waInstance{GREEN_API_ID_INSTANCE}/sendFileByUpload/{GREEN_API_TOKEN}"
-    payload = {'chatId': chat_id, 'caption': 'Here you go!', 'quotedMessageId': message_id}
-    files = [('file', ('image.jpg', open(image_path, 'rb'), 'image/jpeg'))]
-
-    for attempt in range(retries):
-        try:
-            response = requests.post(url, data=payload, files=files)
-            response.raise_for_status()
-            return response.json()
-        except requests.RequestException as e:
-            if attempt < retries - 1:
-                continue
-            return {"error": str(e)}
-
-def response_text(message_id, chat_id, prompt):
-    """
-    Generate a response using the LLM and send it to the user.
-    """
-    try:
-        msg = generate_llm(prompt)
-        send_message(message_id, chat_id, msg)
-    except Exception as e:
-        send_message(message_id, chat_id, "There was an error processing your request.")
-
-def handle_image_generation(message_id, chat_id, prompt):
-    """
-    Generate an image from the provided prompt and send it to the user.
-    """
-    try:
-        image_data, image_path = generate_sd(prompt)
-        if image_data:
-            send_image(message_id, chat_id, image_path)
-        else:
-            send_message(message_id, chat_id, "Failed to generate image. Please try again later.")
-    except Exception as e:
-        send_message(message_id, chat_id, "There was an error generating the image. Please try again later.")
-
-@app.route('/', methods=['GET'])
+    return info
+
+def start_bots():
+    info = refresh_info()
+    telegram_bot_enabled = info['telegram_bot_enabled']
+    
+    if telegram_bot_enabled:
+        start_telegram_bot()
+
+    # Note: WhatsApp bot functionality is not implemented in this Flask version
+
+# Start the Telegram bot in a separate thread when the application starts
+threading.Thread(target=start_bots).start()
+
+# Function to fetch image files and corresponding YAML data from 'cache' directory
+def fetch_image_files():
+    files = os.listdir('cache')
+    image_files = [f for f in files if f.endswith(('.jpg', '.jpeg', '.png'))]
+    response_data = []
+
+    for image_file in image_files:
+        yaml_file = image_file.rsplit('.', 1)[0] + '.yaml'
+        yaml_data = {}
+        if yaml_file in files:
+            with open(os.path.join('cache', yaml_file), 'r') as file:
+                yaml_data = yaml.safe_load(file)
+        response_data.append(ImageFile(image=image_file, yaml_data=yaml_data))
+    
+    return response_data
+
+@app.route('/')
 def index():
-    """
-    Basic endpoint to check if the script is running.
-    """
-    return "Server is running!"
-
-@app.route('/whatsapp', methods=['POST'])
-def whatsapp_webhook():
-    """
-    Handle incoming WhatsApp messages.
-    """
-    data = request.get_json()
-    auth_header = request.headers.get('Authorization', '').strip()
-
-    if auth_header != f"Bearer {WEBHOOK_AUTH_TOKEN}":
-        return jsonify({"error": "Unauthorized"}), 403
-
-    if data.get('typeWebhook') != 'incomingMessageReceived':
-        return jsonify(success=True)
-
-    try:
-        chat_id = data['senderData']['chatId']
-        message_id = data['idMessage']
-        message_data = data.get('messageData', {})
-
-        if 'textMessageData' in message_data:
-            body = message_data['textMessageData']['textMessage'].strip()
-        elif 'extendedTextMessageData' in message_data:
-            body = message_data['extendedTextMessageData']['text'].strip()
-        else:
-            return jsonify(success=True)
-
-    except KeyError as e:
-        return jsonify({"error": f"Missing key in data: {e}"}), 200
-
-    if body.lower().startswith('/imagine'):
-        prompt = body.replace('/imagine', '').strip()
-        if not prompt:
-            send_message(message_id, chat_id, "Please provide a prompt after /imagine.")
-        else:
-            send_message(message_id, chat_id, "Generating...")
-            threading.Thread(target=handle_image_generation, args=(message_id, chat_id, prompt)).start()
-    else:
-        threading.Thread(target=response_text, args=(message_id, chat_id, body)).start()
-
-    return jsonify(success=True)
+    # Render the HTML template with fresh image data
+    image_data = fetch_image_files()
+    return render_template("index.html", image_data=image_data)
+
+@app.route('/info')
+def get_info():
+    info = refresh_info()
+    return jsonify(info)
+
+@app.route('/images')
+def get_images():
+    # Fetch fresh image data
+    image_data = fetch_image_files()
+    response_data = [img.__dict__ for img in image_data]
+    return jsonify(ImageResponse(response_data).__dict__)
+
+@app.route('/cache/<image_name>')
+def get_image(image_name):
+    file_path = os.path.join('cache', image_name)
+    if os.path.exists(file_path):
+        return send_file(file_path)
+    return jsonify({"error": "File not found"}), 404
+
+@app.route('/statics/<image_name>')
+def get_static_image(image_name):
+    file_path = os.path.join('statics', image_name)
+    if os.path.exists(file_path):
+        return send_file(file_path)
+    return jsonify({"error": "File not found"}), 404
+
+@app.route('/yaml/<image_name>')
+def get_embedded_yaml(image_name):
+    file_path = os.path.join('cache', image_name)
+    if not os.path.exists(file_path):
+        return jsonify({"error": "Image file not found"}), 404
+    
+    # Use the function to read YAML payload from image metadata
+    yaml_payload = read_payload_from_image(file_path)
+    if yaml_payload:
+        return jsonify(yaml_payload)
+    return jsonify({"error": "No YAML payload found in the image metadata"}), 404
 
 if __name__ == '__main__':
-    app.run(debug=True, port=PORT, host="0.0.0.0")
+    app.run(debug=True, port=7860, host="0.0.0.0")