Update app.py

app.py

@@ -2,25 +2,31 @@ import gradio as gr
 import requests
 from io import BytesIO
 from PIL import Image
-import os
-# HARDCODED_URL = ""  # Replace with your desired URL
+import hashlib
 
-GLIF_API_TOKEN = os.getenv("GLIF_API_TOKEN1")
-GLIF_API_URL = "https://simple-api.glif.app"
-glif_token_id = 1
-glif_tokens_tried = 0
-no_of_accounts = 3
+# Store registered users in a dictionary (you can use a file or database for persistence)
+registered_users = {}
 
-import gradio as gr
-from PIL import Image
-from io import BytesIO
-import requests
-import os
+# Utility: Hash passwords using SHA-256
+def hash_password(password):
+    return hashlib.sha256(password.encode()).hexdigest()
 
+# Utility: Handle user registration
+def register_user(username, password):
+    if username in registered_users:
+        return f"Username '{username}' is already taken!"
+    registered_users[username] = hash_password(password)
+    return "Registration successful! You can now log in."
+
+# Utility: Handle user login
+def login_user(username, password):
+    hashed_pw = hash_password(password)
+    if username in registered_users and registered_users[username] == hashed_pw:
+        return True, f"Welcome back, {username}!"
+    return False, "Invalid username or password!"
+
+# Generate image function (unchanged)
 def get_image_from_url(url):
-    """
-    Fetches and returns an image from a given URL.
-    """
     try:
         response = requests.get(url, stream=True)
         response.raise_for_status()
@@ -32,54 +38,61 @@ def get_image_from_url(url):
         return f"Error processing image: {e}"
 
 def generate_image(prompt, aspect_ratio, realism):
-    global glif_token_id
-    global GLIF_API_TOKEN
-    global glif_tokens_tried
-    global no_of_accounts
+    # Dummy implementation to show the flow (replace with your GLIF API logic)
+    return f"Generated image for prompt '{prompt}' with aspect ratio {aspect_ratio}."
 
-    payload = {
-        "id": "cm3ugmzv2002gnckiosrwk6xi",  # Replace with appropriate ID if necessary
-        "inputs": [prompt, aspect_ratio, str(realism).lower()],
-    }
-    headers = {"Authorization": f"Bearer {GLIF_API_TOKEN}"}
+# Gradio Interface for Login/Register
+def login_or_register(mode, username, password):
+    if mode == "Register":
+        return register_user(username, password)
+    elif mode == "Login":
+        success, message = login_user(username, password)
+        if success:
+            return gr.update(visible=True), message  # Show the main app if login successful
+    return gr.update(visible=False), message  # Hide the main app if login failed
 
-    try:
-        response_data = requests.post(GLIF_API_URL, json=payload, headers=headers).json()
-        if "error" in response_data:
-            if 'error 429' in response_data['error']:
-                if glif_tokens_tried < no_of_accounts:
-                    glif_token_id = (glif_token_id + 1) % no_of_accounts
-                    glif_tokens_tried += 1
-                    GLIF_API_TOKEN = os.getenv(f"GLIF_API_TOKEN{glif_token_id}")
-                    response_data = generate_image(prompt, aspect_ratio, realism)
-                    glif_tokens_tried = 0
-                    return response_data
-                return "No credits available"
-            return response_data
-        elif "output" in response_data:
-            url = response_data['output']
-            return get_image_from_url(url)  # Return the image directly
-        else:
-            return "Error: Unexpected response from server"
-    except Exception as e:
-        return f"Error: {e}"
+# Gradio Interface for Main App
+def main_app(prompt, aspect_ratio, realism):
+    return generate_image(prompt, aspect_ratio, realism)
 
-# Define the Gradio interface
-interface = gr.Interface(
-    fn=generate_image,
+# Register/Login Interface
+login_interface = gr.Interface(
+    fn=login_or_register,
+    inputs=[
+        gr.Radio(["Login", "Register"], label="Mode"),
+        gr.Textbox(label="Username", placeholder="Enter your username"),
+        gr.Textbox(label="Password", type="password", placeholder="Enter your password"),
+    ],
+    outputs=[
+        gr.State(),  # Pass visibility state
+        gr.Textbox(label="Status"),
+    ],
+)
+
+# Main Interface
+main_interface = gr.Interface(
+    fn=main_app,
     inputs=[
         gr.Textbox(label="Prompt", placeholder="Describe the image you want to generate"),
         gr.Radio(
             choices=["1:1", "3:4", "4:3", "9:16", "16:9", "9:21", "21:9"], 
             label="Aspect Ratio", 
-            value="16:9"  # Default value
+            value="16:9"
         ),
-        gr.Checkbox(label="Realism", value=True),  # Checkbox for realism (True/False)
+        gr.Checkbox(label="Realism", value=True),
     ],
-    outputs=gr.Image(type="pil"),  # Output image
-    title="Image Generator",
-    description="Provide a prompt, select an aspect ratio, and set realism to generate an image.",
+    outputs=gr.Image(type="pil"),
 )
 
-# Launch the interface
-interface.launch()
+# Combine Interfaces
+with gr.Blocks() as app:
+    state = gr.State(visible=False)
+    with gr.Row():
+        gr.Column(login_interface)
+        gr.Column(main_interface, visible=False)  # Initially hide the main app
+    
+    # Logic to handle visibility
+    def toggle_interface(visibility):
+        main_interface.visible = visibility
+
+app.launch()