# import gradio as gr
# import requests
# from PIL import Image
# import base64
# from io import BytesIO
# import logging
# # Set up logging
# logging.basicConfig(level=logging.DEBUG)
# logger = logging.getLogger(__name__)
# # skin_metrics_url = 'https://huggingface.co/spaces/Fynd/skin-care-recommendation-system/backend/upload'
# # recommendation_url = 'https://huggingface.co/spaces/Fynd/skin-care-recommendation-system/backend/recommend'
# # Define the API endpoints
# skin_metrics_url = 'http://127.0.0.1:5000/upload' # Flask backend URL
# recommendation_url = 'http://127.0.0.1:5000/recommend' # Another backend endpoint
# def capture_face_image(file):
# try:
# if file is None:
# return "Please upload an image", None
# # Open the uploaded image file (directly using the file object passed from Gradio)
# image = Image.open(file)
# # Convert image to base64
# buffered = BytesIO()
# image.save(buffered, format="PNG")
# img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
# # Send to backend for skin analysis
# try:
# response = requests.put(
# skin_metrics_url,
# json={'file': img_str},
# timeout=10 # Add timeout
# )
# response.raise_for_status() # Raise exception for bad status codes
# skin_data = response.json() # Skin analysis data from backend
# return skin_data, image # Return both the analysis data and image
# except requests.exceptions.RequestException as e:
# logger.error(f"API request failed: {str(e)}")
# return f"Error in skin analysis: {str(e)}", image
# except Exception as e:
# logger.error(f"Image processing error: {str(e)}")
# return f"Error processing image: {str(e)}", None
# def get_recommendations(tone, skin_type, concerns):
# try:
# # Define the full list of features that the model expects (18 in total)
# all_features = [
# 'normal', 'dry', 'oily', 'combination', 'acne', 'sensitive', 'fine lines', 'wrinkles', 'redness',
# 'dull', 'pore', 'pigmentation', 'blackheads', 'whiteheads', 'blemishes', 'dark circles', 'eye bags', 'dark spots'
# ]
# # Prepare the features dict with all the values set to 0 initially
# features_dict = {feature: 0 for feature in all_features}
# # Update the dictionary with features selected by the user
# for concern in concerns:
# if concern in features_dict:
# features_dict[concern] = 1
# # Prepare the data to send to the backend
# data = {
# 'tone': tone,
# 'type': skin_type,
# 'features': features_dict # Send the full features dictionary
# }
# # Log the data being sent to the backend
# logger.info(f"Sending recommendation request with data: {data}")
# # Make a request to the backend for recommendations
# try:
# response = requests.put(
# recommendation_url,
# json=data,
# timeout=10 # Add timeout
# )
# response.raise_for_status()
# # Log the response status code and content
# logger.info(f"Recommendation API response status: {response.status_code}")
# recommendations = response.json() # Receive recommendations from backend
# # Log the recommendations received from the backend
# logger.info(f"Received recommendations: {recommendations}")
# return recommendations # Return the product recommendations
# except requests.exceptions.RequestException as e:
# logger.error(f"Recommendation API request failed: {str(e)}")
# return {"error": f"Error fetching recommendations: {str(e)}"}
# except Exception as e:
# logger.error(f"Recommendation processing error: {str(e)}")
# return {"error": str(e)}
# # Build the Gradio interface
# with gr.Blocks() as demo:
# # Image upload section
# with gr.Row():
# with gr.Column():
# image_input = gr.Image(
# label="Upload Face Image",
# type="filepath", # Change 'file' to 'filepath'
# interactive=True
# )
# submit_button = gr.Button("Analyze Face")
# # Form section
# with gr.Row():
# with gr.Column():
# tone_input = gr.Slider(
# minimum=1,
# maximum=6,
# label="Skin Tone",
# value=5,
# step=1
# )
# skin_type_input = gr.Radio(
# choices=["All", "Oily", "Normal", "Dry"],
# label="Skin Type",
# value="All"
# )
# acne_input = gr.Radio(
# choices=['Low', 'Moderate', 'Severe'],
# label="Acne Severity",
# value="Moderate", # Default selected value
# interactive=True # Make sure interactive is properly set
# )
# concerns_input = gr.CheckboxGroup(
# choices=[
# 'normal', 'dry', 'oily', 'combination', 'acne', 'sensitive', 'fine lines', 'wrinkles', 'redness',
# 'dull', 'pore', 'pigmentation', 'blackheads', 'whiteheads', 'blemishes', 'dark circles', 'eye bags', 'dark spots'
# ],
# label="Skin Concerns"
# )
# form_submit_button = gr.Button("Get Recommendations")
# # Output section
# with gr.Row():
# recommendation_output = gr.JSON(label="Recommendations")
# # Event handlers
# submit_button.click(
# fn=capture_face_image,
# inputs=image_input,
# outputs=[recommendation_output, image_input]
# )
# form_submit_button.click(
# fn=get_recommendations,
# inputs=[tone_input, skin_type_input, concerns_input],
# outputs=recommendation_output
# )
# # Launch the interface
# demo.launch(
# # server_name="127.0.1",
# # server_port=7863,
# debug=True,
# share=True
# )
# gr.close_all()
import os
import threading
import gradio as gr
import requests
from flask import Flask, jsonify
from flask_restful import Api, Resource, reqparse
from PIL import Image
from io import BytesIO
import base64
import logging
# Initialize Flask app
app = Flask(__name__)
api = Api(app)
# Set up logging
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
# Define the model loading and prediction logic (for illustration)
def load_image(img_path):
img = Image.open(img_path)
img_tensor = np.expand_dims(np.array(img), axis=0) # Dummy placeholder for model processing
img_tensor /= 255.0
return img_tensor
def prediction_skin(img_path):
return "Dry_skin" # Placeholder
def prediction_acne(img_path):
return "Low" # Placeholder
# Flask API resources
class SkinMetrics(Resource):
def put(self):
args = img_put_args.parse_args()
file = args['file']
starter = file.find(',')
image_data = file[starter + 1:]
image_data = bytes(image_data, encoding="ascii")
im = Image.open(BytesIO(base64.b64decode(image_data + b'==')))
filename = 'image.png'
file_path = os.path.join('./static', filename)
im.save(file_path)
skin_type = prediction_skin(file_path)
acne_type = prediction_acne(file_path)
return jsonify({'type': skin_type, 'acne': acne_type})
class Recommendation(Resource):
def put(self):
args = rec_args.parse_args()
features = args['features']
tone = args['tone']
skin_type = args['type'].lower()
# Recommendation logic here
return jsonify({'message': 'Recommendation response'})
# Flask API URL arguments
img_put_args = reqparse.RequestParser()
img_put_args.add_argument("file", help="Please provide a valid image file", required=True)
rec_args = reqparse.RequestParser()
rec_args.add_argument("tone", type=int, help="Argument required", required=True)
rec_args.add_argument("type", type=str, help="Argument required", required=True)
rec_args.add_argument("features", type=dict, help="Argument required", required=True)
# Add resources to the Flask app
api.add_resource(SkinMetrics, "/upload")
api.add_resource(Recommendation, "/recommend")
# Gradio frontend code
def capture_face_image(file):
try:
if file is None:
return "Please upload an image", None
image = Image.open(file)
buffered = BytesIO()
image.save(buffered, format="PNG")
img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
# Send to backend for skin analysis
response = requests.put(
"http://127.0.0.1:5000/upload",
json={'file': img_str},
timeout=10
)
response.raise_for_status()
skin_data = response.json()
return skin_data, image
except requests.exceptions.RequestException as e:
logger.error(f"API request failed: {str(e)}")
return f"Error in skin analysis: {str(e)}", None
def get_recommendations(tone, skin_type, concerns):
try:
all_features = [
'normal', 'dry', 'oily', 'combination', 'acne', 'sensitive', 'fine lines', 'wrinkles', 'redness',
'dull', 'pore', 'pigmentation', 'blackheads', 'whiteheads', 'blemishes', 'dark circles', 'eye bags', 'dark spots'
]
# Update the features_dict based on selected concerns
features_dict = {feature: 0 for feature in all_features}
for concern in concerns:
if concern in features_dict:
features_dict[concern] = 1
data = {
'tone': tone,
'type': skin_type,
'features': features_dict
}
response = requests.put(
"http://127.0.0.1:5000/recommend",
json=data,
timeout=10
)
response.raise_for_status()
recommendations = response.json()
# Generate HTML content for cards (simplified for this example)
product_cards = ""
if recommendations.get("general"):
for category, products in recommendations["general"].items():
for product in products:
card_html = f"""
![{product['name']}]({product['img']})
{product['name']}
{product['brand']}
{product['price']}
Buy Now
"""
product_cards += card_html
grid_html = f"""
{product_cards}
"""
return grid_html
except requests.exceptions.RequestException as e:
logger.error(f"Recommendation API request failed: {str(e)}")
return f"Error fetching recommendations: {str(e)}"
# Gradio UI
with gr.Blocks() as demo:
with gr.Row():
image_input = gr.Image(type="filepath")
submit_button = gr.Button("Analyze Face")
with gr.Row():
tone_input = gr.Slider(minimum=1, maximum=6)
skin_type_input = gr.Radio(choices=["All", "Oily", "Normal", "Dry"])
acne_input = gr.Radio(choices=["Low", "Moderate", "Severe"])
concerns_input = gr.CheckboxGroup(choices=all_features)
form_submit_button = gr.Button("Get Recommendations")
recommendation_output = gr.HTML()
submit_button.click(fn=capture_face_image, inputs=image_input, outputs=recommendation_output)
form_submit_button.click(fn=get_recommendations, inputs=[tone_input, skin_type_input, concerns_input], outputs=recommendation_output)
# Function to run Flask app
def run_flask():
app.run(debug=False, use_reloader=False, host="0.0.0.0", port=5000)
# Function to run Gradio app
def run_gradio():
demo.launch(share=True, server_name="0.0.0.0", server_port=7861)
# Run both Flask and Gradio together using threads
if __name__ == "__main__":
flask_thread = threading.Thread(target=run_flask)
gradio_thread = threading.Thread(target=run_gradio)
flask_thread.start()
gradio_thread.start()
flask_thread.join()
gradio_thread.join()