Initial commit

.gitignore

@@ -0,0 +1,4 @@
+.env
+myenv
+*.pyc
+__pycache__/

api/main.py

@@ -0,0 +1,20 @@
+from fastapi import FastAPI, Request
+from .routers import reply_generator
+from .routers import pickup_line_generator
+from .routers import looks_analyzer
+
+app = FastAPI()
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+    response = await call_next(request)
+    return response
+
+@app.get("/")
+async def root():
+    return {'response':'Hello'}
+
+app.include_router(reply_generator.router, prefix="/api")
+app.include_router(pickup_line_generator.router, prefix="/api")
+app.include_router(looks_analyzer.router, prefix="/api")
+

api/routers/looks_analyzer.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+from typing import Optional
+from src.looks_analyzer.generate import Graph
+
+router = APIRouter()
+reply_generator = Graph()
+graph = reply_generator.run()
+
+class UserRequest(BaseModel):
+    image_base64: Optional[str] = None
+    user_query: Optional[str] = None
+
+
+@router.post("/looks-analyzer")
+async def generate_reply(request: UserRequest):
+    """
+    Endpoint to analyze looks
+    """
+    config={"configurable": {"thread_id": "looks-analyzer-thread"}}
+
+    result = graph.invoke({
+        'image': request.image_base64,
+        'messages': [request.user_query]
+    },config=config)
+    # print('The result is:', result)
+    return {'response':result['suggestions']}

api/routers/pickup_line_generator.py

@@ -0,0 +1,32 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+from typing import Optional
+from api.stored_data import stored_data
+from src.pickup_line_generator.generate import Graph
+from typing import List
+
+router = APIRouter()
+pickup_generator = Graph()
+graph = pickup_generator.run()
+
+class UserRequest(BaseModel):
+    user_query: Optional[str] = None
+    tones: Optional[List[str]] = None
+    attributes: list
+
+
+@router.post("/pickup-line-generator")
+async def generate_reply(request: UserRequest):
+    """
+    Endpoint to extract conversation from a base64-encoded image
+    """
+    config={"configurable": {"thread_id": "reply-generator-thread"}}
+
+    result = graph.invoke({
+        'messages': [request.user_query],
+        'tones': request.tones,
+        'attributes': request.attributes
+    },config=config)
+    print('The result is:', result)
+    return {'response':result['pickup_lines']}
+    

api/routers/reply_generator.py

@@ -0,0 +1,36 @@
+import base64
+from fastapi import APIRouter
+from pydantic import BaseModel
+from typing import Optional
+from src.conversation_extractor.extractor import ConversationExtractor
+from api.stored_data import stored_data
+from src.reply_generator.generate import Graph
+from typing import List
+
+router = APIRouter()
+reply_generator = Graph()
+graph = reply_generator.run()
+
+class UserRequest(BaseModel):
+    image_base64: str
+    user_query: Optional[str] = None
+    tones: Optional[List[str]] = None
+
+@router.post("/reply-generator")
+async def generate_reply(request: UserRequest):
+    """
+    Endpoint to extract conversation from a base64-encoded image
+    """
+    config={"configurable": {"thread_id": "reply-generator-thread"}}
+    image_bytes = base64.b64decode(request.image_base64)
+    conversation_text = ConversationExtractor().extract_conversation(image_bytes)
+    stored_data['conversation_context'] = conversation_text
+
+    result = graph.invoke({
+        'messages': [request.user_query],
+        'tones': request.tones,
+        'conversation_chat': stored_data['conversation_context']
+    },config=config)
+    print('The result is:', result)
+    return {'response':result['replies']}
+    

api/stored_data.py

@@ -0,0 +1,9 @@
+stored_data = {}
+stored_data['conversation_context']= '''
+miss u
+*
+same babe
+do u want to hang out with me
+love to
+fine when?
+'''

requirements.txt

@@ -0,0 +1,10 @@
+langchain-groq
+langchain-openai
+pydantic
+google-genai
+langgraph
+requests
+fastapi
+uvicorn 
+python-dotenv
+streamlit

src/conversation_extractor/extractor.py

@@ -0,0 +1,32 @@
+
+from google import genai
+from google.genai import types
+from src.utils.models_loader import ocr_llm
+from .prompts import prompt
+
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+os.environ['GOOGLE_API_KEY']=os.getenv('GOOGLE_API_KEY')
+
+class ConversationExtractor:
+    def __init__(self):
+        self.client = genai.Client()
+        self.model_name = ocr_llm
+        self.prompt = prompt
+
+    def extract_conversation(self, image_bytes: bytes) -> str:
+        """
+        Extract conversation text from an image.
+        :param image_bytes: Binary content of the image
+        :return: Extracted conversation text
+        """
+        response = self.client.models.generate_content(
+            model=self.model_name,
+            contents=[
+                types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg"),
+                self.prompt
+            ]
+        )
+        return response.text

src/conversation_extractor/prompts.py

@@ -0,0 +1,8 @@
+
+prompt = (
+    "Extract only the conversation text between two persons from this image. "
+    "Ignore timestamps, emojis, or extra elements. "
+    "Preserve dialogue order. "
+    "If names exist, use them; otherwise label speakers Person A and Person B. "
+    "Output strictly as chat dialogue lines. Return only dialogue."
+)

src/looks_analyzer/generate.py

@@ -0,0 +1,48 @@
+from src.utils.models_loader import ocr_llm
+from .prompts import prompt
+from .state import State
+from langgraph.graph import StateGraph, START, END
+from langgraph.checkpoint.memory import MemorySaver
+from google.genai import types
+from google import genai
+from langchain_core.messages import HumanMessage
+
+
+
+class Generate:
+    def __init__(self):
+        self.client = genai.Client()
+        self.model_name = ocr_llm
+
+    
+    def run(self, state:State):
+        latest_human_message = next(
+            (msg for msg in reversed(state['messages']) if isinstance(msg, HumanMessage)),
+            None
+        )
+        response = self.client.models.generate_content(
+        model=self.model_name,
+
+        contents=[
+            types.Part.from_bytes(data=state['image'], mime_type="image/jpeg"),
+            prompt(latest_human_message)
+        ]
+        )
+        print('The prompt is:', prompt(latest_human_message))
+        return {
+            'messages':[{'role': 'assistant', 'content': response.text}],
+            'suggestions': response.text
+        }
+
+     
+
+class Graph:
+    def __init__(self):
+        self.memory = MemorySaver()
+    
+    def run(self):
+        workflow = StateGraph(State)
+        workflow.add_node('generate_pickups', Generate().run)
+        workflow.add_edge(START,'generate_pickups')
+        workflow.add_edge('generate_pickups',END)
+        return workflow.compile(checkpointer=self.memory)

src/looks_analyzer/prompts.py

@@ -0,0 +1,14 @@
+def prompt(user_query: str = None) -> str:
+    base_prompt = '''
+    Analyze the person in this image and evaluate their overall appearance, style, and presentation. 
+    Provide constructive suggestions to enhance their looks, grooming, and fashion. 
+    Focus on actionable, practical, and personalized recommendations. 
+    Do not add unrelated details or opinions. 
+    Return concise, clear advice only shortly in 40 words only.
+    '''
+    
+    if user_query:
+        return base_prompt + f'\nAlso, take into account the user’s request: "{user_query}".'
+    else:
+        return base_prompt
+

src/looks_analyzer/state.py

@@ -0,0 +1,8 @@
+from typing import Optional , TypedDict , Annotated
+from langgraph.graph.message import add_messages
+
+
+class State(TypedDict):
+    image: bytes
+    messages: Annotated[list, add_messages]
+    suggestions: str

src/pickup_line_generator/generate.py

@@ -0,0 +1,35 @@
+from src.utils.models_loader import reply_llm
+from .prompts import pickup_line_prompt
+from .schemas import PickupFormatter
+from .state import State
+from langchain_core.messages import SystemMessage, HumanMessage, FunctionMessage
+from langgraph.graph import StateGraph, START, END
+from langgraph.checkpoint.memory import MemorySaver
+
+class Generate:
+    def __init__(self):
+        self.llm = reply_llm
+    
+    def run(self, state:State):
+        messages = [SystemMessage(content=pickup_line_prompt),
+        FunctionMessage(name='attrubutes',content=f'''The attributes of person are: {state['attributes']}'''),
+         HumanMessage(content=f'''The required tone: {state["tones"]}''')]
+        pickup_lines = reply_llm.with_structured_output(PickupFormatter).invoke(messages)
+        return {
+            'messages':[{'role': 'assistant', 'content': str(pickup_lines.model_dump())}],
+            'pickup_lines': pickup_lines.model_dump()
+        }
+        
+
+class Graph:
+    def __init__(self):
+        self.memory = MemorySaver()
+    
+    def run(self):
+        workflow = StateGraph(State)
+        workflow.add_node('generate_pickups', Generate().run)
+        workflow.add_edge(START,'generate_pickups')
+        workflow.add_edge('generate_pickups',END)
+        return workflow.compile(checkpointer=self.memory)
+
+

src/pickup_line_generator/prompts.py

@@ -0,0 +1,12 @@
+pickup_line_prompt ='''
+You are a smart conversation coach. 
+You will be given:
+1. The recent conversation between two people (context).
+2. The attributes of the target person (e.g., ambitious, classy, fitness freak, spiritual, funny).
+
+Your task is to generate 5 highly personalized pickup lines or impressive responses that can attract or influence the target person. 
+Adapt the style of the lines to match both the context and the person’s attributes. 
+They can be romantic, professional, or casual depending on the context. 
+Each line should be unique, concise, and impactful. 
+Return exactly 5 lines, numbered 1 to 5, without extra commentary.
+'''

src/pickup_line_generator/schemas.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+class PickupFormatter(BaseModel):
+    pickup_line1: str
+    pickup_line2: str
+    pickup_line3: str
+    pickup_line4: str

src/pickup_line_generator/state.py

@@ -0,0 +1,10 @@
+from typing import Optional , TypedDict , Annotated
+from langgraph.graph.message import add_messages
+
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+    conversation_chat: str
+    tones: list
+    attributes:list
+    pickup_lines:dict

src/reply_generator/generate.py

@@ -0,0 +1,38 @@
+from src.utils.models_loader import reply_llm
+from .prompts import prompt
+from .schemas import ReplyFormatter
+from .state import State
+from langchain_core.messages import SystemMessage, HumanMessage, FunctionMessage
+from langgraph.graph import StateGraph, START, END
+from langgraph.checkpoint.memory import MemorySaver
+
+class Generate:
+    def __init__(self):
+        self.llm = reply_llm
+    
+    def run(self, state:State):
+        messages = [SystemMessage(content=prompt),
+        FunctionMessage(name='conversation-context',content=state['conversation_chat']),
+         HumanMessage(content=f'''The required tone: {state["tones"]}''')]
+        reply = reply_llm.with_structured_output(ReplyFormatter).invoke(messages)
+        print('The reply is:',reply)
+        print(reply.model_dump())
+        
+        return {
+            'messages':[{'role': 'assistant', 'content': str(reply.model_dump())}],
+            'replies': reply.model_dump()
+        }
+        
+
+class Graph:
+    def __init__(self):
+        self.memory = MemorySaver()
+    
+    def run(self):
+        workflow = StateGraph(State)
+        workflow.add_node('generate_reply', Generate().run)
+        workflow.add_edge(START,'generate_reply')
+        workflow.add_edge('generate_reply',END)
+        return workflow.compile(checkpointer=self.memory)
+
+

src/reply_generator/prompts.py

@@ -0,0 +1,10 @@
+prompt = '''
+"You are a conversation assistant. Read the dialogue between two people. "
+"Suggest the best possible 5 replies for the next message, considering context and relationship. "
+"Your reply should be natural, concise, and impressive. "
+"If it’s romantic, be charming but respectful. "
+"If it’s professional, be polite, confident, and value-adding. "
+"If it’s casual, be friendly and engaging. "
+"The tone to response will be provided by the human themselves"
+"Return only the suggested replies text, nothing else."
+'''

src/reply_generator/schemas.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+class ReplyFormatter(BaseModel):
+    reply1: str
+    reply2: str
+    reply3: str
+    reply4: str

src/reply_generator/state.py

@@ -0,0 +1,9 @@
+from typing import Optional , TypedDict , Annotated
+from langgraph.graph.message import add_messages
+
+
+class State(TypedDict):
+    messages: Annotated[list, add_messages]
+    conversation_chat: str
+    tones: list
+    replies:dict

src/utils/models_loader.py

@@ -0,0 +1,8 @@
+from langchain_groq import ChatGroq
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+os.environ['GROQ_API_KEY']=os.getenv('GROQ_API_KEY')
+reply_llm = ChatGroq(model='llama-3.1-8b-instant')
+ocr_llm = "gemini-2.5-flash"

streamlit/app.py

@@ -0,0 +1,2 @@
+import streamlit as st
+st.set_page_config(page_title="REVEL-RIZZ", layout="centered")

streamlit/pages/check_looks.py

@@ -0,0 +1,47 @@
+import streamlit as st
+import requests
+import base64
+
+# FastAPI endpoint
+API_URL = "http://localhost:8000/api/looks-analyzer"  # Change if deployed elsewhere
+
+st.set_page_config(page_title="Looks Analyzer", page_icon="🧑‍🎨", layout="centered")
+
+st.title("🧑‍🎨 Looks Analyzer")
+st.write("Upload your image and get style & looks suggestions!")
+
+# Upload image
+uploaded_file = st.file_uploader("Upload an image (JPG/PNG)", type=["jpg", "jpeg", "png"])
+
+# User query input
+user_query = st.text_area("Enter your query (optional)", placeholder="e.g., How do I look in this outfit?")
+
+# Button to trigger API
+if st.button("Analyze Looks"):
+    if uploaded_file is None:
+        st.error("⚠️ Please upload an image.")
+    else:
+        try:
+            # Convert image to base64
+            image_bytes = uploaded_file.read()
+            image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+
+            payload = {
+                "image_base64": image_base64,
+                "user_query": user_query if user_query.strip() else None,
+            }
+
+            with st.spinner("✨ Analyzing your looks..."):
+                response = requests.post(API_URL, json=payload)
+
+            if response.status_code == 200:
+                data = response.json()
+                st.success("✅ Analysis complete!")
+                st.write("### Suggestions:")
+                st.json(data)
+             
+            else:
+                st.error(f"❌ Error: {response.status_code} - {response.text}")
+
+        except Exception as e:
+            st.error(f"🚨 An error occurred: {str(e)}")

streamlit/pages/pickup_line_generator.py

@@ -0,0 +1,53 @@
+import streamlit as st
+import requests
+
+# FastAPI endpoint
+API_URL = "http://localhost:8000/api/pickup-line-generator"  # Change if deployed elsewhere
+
+st.set_page_config(page_title="Pickup Line Generator", page_icon="💘", layout="centered")
+
+st.title("💘 Pickup Line Generator")
+st.write("Generate fun and creative pickup lines with customizable tones and attributes.")
+
+# User query input
+user_query = st.text_area("Your some Qureies? (optional)", placeholder="e.g., I have to impress her by tomorrow.")
+
+# Tones (multi-select)
+available_tones = ["romantic", "funny", "cheesy", "flirty", "sarcastic", "friendly"]
+tones = st.multiselect("Select tones (optional)", available_tones)
+
+# Attributes (must provide at least one)
+attributes = st.text_area(
+    "Enter attributes of that person (comma-separated, required)", 
+    placeholder="e.g., coffee lover, programmer, bookworm"
+)
+
+# Button to trigger API
+if st.button("Generate Pickup Line"):
+    if not attributes.strip():
+        st.error("⚠️ Please enter at least one attribute.")
+    else:
+        try:
+            # Process attributes into list
+            attributes_list = [attr.strip() for attr in attributes.split(",") if attr.strip()]
+
+            payload = {
+                "user_query": user_query if user_query.strip() else None,
+                "tones": tones if tones else None,
+                "attributes": attributes_list,
+            }
+
+            with st.spinner("💫 Generating pickup lines..."):
+                response = requests.post(API_URL, json=payload)
+
+            if response.status_code == 200:
+                data = response.json()
+                st.success("✅ Pickup lines generated successfully!")
+                st.write("### Your Pickup Lines:")
+                st.json(response.json())
+
+            else:
+                st.error(f"❌ Error: {response.status_code} - {response.text}")
+
+        except Exception as e:
+            st.error(f"🚨 An error occurred: {str(e)}")

streamlit/pages/reply_generator.py

@@ -0,0 +1,54 @@
+import streamlit as st
+import requests
+import base64
+
+# FastAPI endpoint
+API_URL = "http://localhost:8000/api/reply-generator"  # Change if deployed elsewhere
+
+st.set_page_config(page_title="Reply Generator", page_icon="💬", layout="centered")
+
+st.title("💬 Reply Generator")
+st.write("Upload an image, ask a question, and get AI-powered replies.")
+
+# Upload image
+uploaded_file = st.file_uploader("Upload an image (JPG/PNG)", type=["jpg", "jpeg", "png"])
+
+# User query input
+user_query = st.text_area("Enter your query", placeholder="Type your question here...")
+
+# Tones (multi-select)
+available_tones = ["formal", "casual", "friendly", "professional", "humorous"]
+tones = st.multiselect("Select tones (optional)", available_tones)
+
+# Button to trigger API
+if st.button("Generate Reply"):
+    if uploaded_file is None:
+        st.error("⚠️ Please upload an image first.")
+    elif not user_query.strip():
+        st.error("⚠️ Please enter a query.")
+    else:
+        try:
+            # Convert image to base64
+            image_bytes = uploaded_file.read()
+            image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+
+            payload = {
+                "image_base64": image_base64,
+                "user_query": user_query,
+                "tones": tones if tones else None,
+            }
+
+            with st.spinner("⏳ Generating reply..."):
+                response = requests.post(API_URL, json=payload)
+
+            if response.status_code == 200:
+                data = response.json()
+                st.success("✅ Reply generated successfully!")
+                st.write("### Response:")
+                st.json(response.json())
+   
+            else:
+                st.error(f"❌ Error: {response.status_code} - {response.text}")
+
+        except Exception as e:
+            st.error(f"🚨 An error occurred: {str(e)}")