Update app.py

app.py

@@ -1,292 +1,96 @@
 from __future__ import annotations
-import os
-import json
+
+import time
 import uuid
 import re
-import time
-from dataclasses import dataclass, asdict
 from pathlib import Path
-from typing import List, Dict, Any, Optional, Tuple
 import streamlit as st
 
-# ---------- Config ----------
-DATA_FILE = Path("users.json")
-FEEDBACK_FILE = Path("feedback.json")
-AVATAR_DIR = Path("avatars")
-MODEL = "llama-3.3-70b-versatile"
-
-AVATAR_DIR.mkdir(exist_ok=True)
-
-if not DATA_FILE.exists():
-    DATA_FILE.write_text("[]", encoding="utf-8")
-
-if not FEEDBACK_FILE.exists():
-    FEEDBACK_FILE.write_text("[]", encoding="utf-8")
-
-# ---------- Data model ----------
-@dataclass
-class Profile:
-    id: str
-    username: str
-    offers: List[str]
-    wants: List[str]
-    availability: str
-    preferences: str
-    avatar: Optional[str] = None
-
-    @staticmethod
-    def from_dict(d: Dict[str, Any]) -> "Profile":
-        return Profile(
-            id=str(d.get("id") or uuid.uuid4()),
-            username=str(d.get("username") or "").strip(),
-            offers=list(d.get("offers") or []),
-            wants=list(d.get("wants") or []),
-            availability=str(d.get("availability") or ""),
-            preferences=str(d.get("preferences") or ""),
-            avatar=d.get("avatar"),
-        )
-
-    def to_dict(self) -> Dict[str, Any]:
-        return asdict(self)
-
-# ---------- Storage & validation ----------
-class ProfileStore:
-    def __init__(self, path: Path = DATA_FILE) -> None:
-        self.path = path
-        self._ensure_file()
-
-    def _ensure_file(self) -> None:
-        if not self.path.exists():
-            self.path.write_text("[]", encoding="utf-8")
-
-    def load_all(self) -> List[Profile]:
-        try:
-            data = json.loads(self.path.read_text(encoding="utf-8"))
-            return [Profile.from_dict(d) for d in data if isinstance(d, dict)]
-        except json.JSONDecodeError:
-            return []
-
-    def save_all(self, profiles: List[Profile]) -> None:
-        data = [p.to_dict() for p in profiles]
-        self.path.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
-
-    def find_by_username(self, username: str) -> Optional[Profile]:
-        username = (username or "").strip()
-        if not username:
-            return None
-        for p in self.load_all():
-            if p.username.lower() == username.lower():
-                return p
-        return None
-
-    def add_or_update(self, profile: Profile) -> Tuple[bool, str]:
-        ok, err = validate_profile(profile)
-        if not ok:
-            return False, f"Validation failed: {err}"
-        profiles = self.load_all()
-        existing = next((p for p in profiles if p.username.lower() == profile.username.lower()), None)
-        if existing:
-            existing.offers = profile.offers
-            existing.wants = profile.wants
-            existing.availability = profile.availability
-            existing.preferences = profile.preferences
-            existing.avatar = profile.avatar
-            self.save_all(profiles)
-            return True, "Profile updated."
-        else:
-            if not profile.id:
-                profile.id = str(uuid.uuid4())
-            profiles.append(profile)
-            self.save_all(profiles)
-            return True, "Profile created."
-
-    def delete(self, username: str) -> Tuple[bool, str]:
-        profiles = self.load_all()
-        new = [p for p in profiles if p.username.lower() != username.lower()]
-        if len(new) == len(profiles):
-            return False, "Profile not found."
-        self.save_all(new)
-        return True, "Profile deleted."
-
-def validate_profile(profile: Profile) -> Tuple[bool, Optional[str]]:
-    if not profile.username or not profile.username.strip():
-        return False, "Username is required."
-    if len(profile.username.strip()) > 60:
-        return False, "Username must be 60 characters or fewer."
-    if not profile.offers and not profile.wants:
-        return False, "At least one offer or want is required."
-    for s in profile.offers + profile.wants:
-        if not isinstance(s, str) or not s.strip():
-            return False, "Offers and wants must be non-empty strings."
-        if len(s) > 120:
-            return False, "Individual skill entries must be 120 characters or fewer."
-    return True, None
-
-# ---------- Utilities ----------
-def normalize_skill_list(text: Optional[str]) -> List[str]:
-    if not text:
-        return []
-    for sep in ["\n", ",", ";"]:
-        text = text.replace(sep, "|")
-    items = [i.strip() for i in text.split("|") if i.strip()]
-    seen = set()
-    out = []
-    for it in items:
-        key = it.lower()
-        if key not in seen:
-            seen.add(key)
-            out.append(it)
-    return out
-
-def make_prompt_for_matching(current_user: Profile, all_users: List[Profile], top_k: int = 5) -> Tuple[str, str]:
-    users_desc = []
-    for u in all_users:
-        if u.id == current_user.id:
-            continue
-        users_desc.append({
-            "id": u.id,
-            "username": u.username,
-            "offers": u.offers,
-            "wants": u.wants,
-            "availability": u.availability,
-            "preferences": u.preferences,
-        })
-
-    system_instructions = (
-        "You are a matchmaking assistant for a free skill-exchange platform. "
-        "Recommend the best matches with JSON output only."
-    )
-
-    user_message = json.dumps({
-        "current_user": current_user.to_dict(),
-        "candidates": users_desc,
-        "top_k": top_k
-    }, ensure_ascii=False)
-
-    return system_instructions, user_message
-
-# ---------- Groq helper ----------
-try:
-    from groq import Groq
-except Exception:
-    Groq = None
-
-def init_groq_client():
-    api_key = os.getenv("GROQ_API_KEY")
-    if not api_key or Groq is None:
-        return None
-    try:
-        return Groq(api_key=api_key)
-    except:
-        return None
-
-def ask_groq_for_matches(system_instructions: str, user_message: str, model: str = MODEL):
-    client = init_groq_client()
-    if client is None:
-        raise RuntimeError("Groq client not initialized. Set GROQ_API_KEY.")
-
-    messages = [
-        {"role": "system", "content": system_instructions},
-        {"role": "user", "content": user_message},
-    ]
-    resp = client.chat.completions.create(messages=messages, model=model)
-    content = resp.choices[0].message.content or ""
-    json_match = re.search(r"(\[\s*\{[\s\S]*?\}\s*\])", content)
-    if not json_match:
-        raise RuntimeError("No JSON array found in LLM response.")
-    return json.loads(json_match.group(1))
-
-# ---------- Feedback ----------
-def load_feedback() -> List[Dict[str, Any]]:
-    try:
-        return json.loads(FEEDBACK_FILE.read_text(encoding="utf-8"))
-    except:
-        return []
-
-def save_feedback(entry: Dict[str, Any]):
-    data = load_feedback()
-    data.append(entry)
-    FEEDBACK_FILE.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
-
-# ---------- Local matching fallback ----------
-def calculate_local_matches(current: Profile, candidates: List[Profile], top_k: int = 3) -> List[Dict[str, Any]]:
-    matches = []
-    for cand in candidates:
-        if cand.id == current.id:
-            continue
-            
-        score = 0
-        offers_set = set(o.lower() for o in cand.offers)
-        wants_set = set(w.lower() for w in cand.wants)
-        cur_offers = set(o.lower() for o in current.offers)
-        cur_wants = set(w.lower() for w in current.wants)
-
-        score += len(offers_set & cur_wants) * 30
-        score += len(cur_offers & wants_set) * 30
-        
-        if cand.availability and current.availability:
-            if cand.availability.lower() in current.availability.lower() or current.availability.lower() in cand.availability.lower():
-                score += 20
-                
-        if cand.preferences and current.preferences:
-            if cand.preferences.lower() in current.preferences.lower() or current.preferences.lower() in cand.preferences.lower():
-                score += 20
-
-        matches.append({
-            "id": cand.id,
-            "username": cand.username,
-            "score": min(100, score),
-            "reason": "Local scoring",
-            "avatar": cand.avatar
-        })
-
-    return sorted(matches, key=lambda x: x["score"], reverse=True)[:top_k]
-
-# ---------- Streamlit UI ----------
-st.set_page_config(page_title="AI Skill Swap", page_icon="🤝", layout="wide")
-
-# ★ SIMPLE LIGHT THEME CSS ★
-base_css = """
-.card{padding:16px;border-radius:12px;background:#ffffff;color:#111827;box-shadow:0 6px 18px rgba(2,6,23,0.06);margin-bottom:12px}
-.avatar{width:64px;height:64px;border-radius:10px;object-fit:cover}
-.match-score{font-weight:700}
-.feedback-floating{position:fixed;bottom:20px;right:20px;background:#4f46e5;color:white;border-radius:50%;width:60px;height:60px;display:flex;align-items:center;justify-content:center;font-size:28px;cursor:pointer;box-shadow:0 4px 10px rgba(0,0,0,0.28);z-index:9999;}
-"""
-st.markdown(f"<style>{base_css}</style>", unsafe_allow_html=True)
-
-# Header with logo
+from config import AVATAR_DIR
+from models import Profile
+from storage import ProfileStore
+from utils import normalize_skill_list, make_prompt_for_matching
+from groq_client import ask_groq_for_matches
+from matching import calculate_local_matches
+from feedback import save_feedback
+from ui_styles import BASE_CSS
+
+# ---------- Streamlit Config ----------
+st.set_page_config(
+    page_title="AI Skill Swap",
+    page_icon="🤝",
+    layout="wide",
+)
+
+st.markdown(f"<style>{BASE_CSS}</style>", unsafe_allow_html=True)
+
+# ---------- Header ----------
 col_logo, col_title = st.columns([1, 8])
+
 with col_logo:
     try:
         st.image("logo.jpg", width=100)
     except:
-        st.image("https://via.placeholder.com/100x100/4F46E5/FFFFFF?text=🤝", width=100)
+        st.image(
+            "https://via.placeholder.com/100x100/4F46E5/FFFFFF?text=🤝",
+            width=100,
+        )
+
 with col_title:
     st.title("AI Skill Swap — Match & Exchange Skills")
     st.caption("Connect, Learn, and Grow Together")
 
+# ---------- Store ----------
 store = ProfileStore()
 
-# ----- Sidebar Profile Form -----
+# ---------- Sidebar: Profile Form ----------
 with st.sidebar:
     st.header("Your profile")
+
     with st.form("profile_form"):
-        username = st.text_input("Username", value=st.session_state.get("username", ""))
-        offers_text = st.text_area("Skills you can teach", value=st.session_state.get("offers_text", ""))
-        wants_text = st.text_area("Skills you want to learn", value=st.session_state.get("wants_text", ""))
-        availability = st.text_input("Availability(Day/Night)", value=st.session_state.get("availability", ""))
-        preferences = st.text_input("Language Preferences", value=st.session_state.get("preferences", ""))
-        avatar_file = st.file_uploader("Upload avatar (optional)", type=["png", "jpg", "jpeg"])
+        username = st.text_input(
+            "Username",
+            value=st.session_state.get("username", ""),
+        )
+
+        offers_text = st.text_area(
+            "Skills you can teach",
+            value=st.session_state.get("offers_text", ""),
+        )
+
+        wants_text = st.text_area(
+            "Skills you want to learn",
+            value=st.session_state.get("wants_text", ""),
+        )
+
+        availability = st.text_input(
+            "Availability (Day/Night)",
+            value=st.session_state.get("availability", ""),
+        )
+
+        preferences = st.text_input(
+            "Language Preferences",
+            value=st.session_state.get("preferences", ""),
+        )
+
+        avatar_file = st.file_uploader(
+            "Upload avatar (optional)",
+            type=["png", "jpg", "jpeg"],
+        )
+
         save = st.form_submit_button("Save / Update profile")
 
         if save:
             offers = normalize_skill_list(offers_text)
             wants = normalize_skill_list(wants_text)
+
             avatar_path = None
             if avatar_file and username.strip():
                 safe = re.sub(r"[^A-Za-z0-9_.-]", "_", username.strip())
                 ext = Path(avatar_file.name).suffix
-                avatar_path = str(AVATAR_DIR / f"{safe}_{int(time.time())}{ext}")
+                avatar_path = str(
+                    AVATAR_DIR / f"{safe}_{int(time.time())}{ext}"
+                )
                 with open(avatar_path, "wb") as f:
                     f.write(avatar_file.getbuffer())
 
@@ -297,10 +101,11 @@ with st.sidebar:
                 wants=wants,
                 availability=availability.strip(),
                 preferences=preferences.strip(),
-                avatar=avatar_path
+                avatar=avatar_path,
             )
 
             ok, msg = store.add_or_update(profile)
+
             if ok:
                 st.success(msg)
                 st.session_state["username"] = username
@@ -313,6 +118,7 @@ with st.sidebar:
 
     st.markdown("---")
     st.header("Load / Delete")
+
     profiles = store.load_all()
     options = ["-- new profile --"] + [p.username for p in profiles]
     selected = st.selectbox("Choose profile", options)
@@ -328,121 +134,173 @@ with st.sidebar:
             st.rerun()
 
     if st.button("Delete profile") and selected != "-- new profile --":
-        ok, m = store.delete(selected)
+        ok, msg = store.delete(selected)
         if ok:
-            st.success(m)
-            for k in ["username","offers_text","wants_text","availability","preferences"]:
+            st.success(msg)
+            for k in [
+                "username",
+                "offers_text",
+                "wants_text",
+                "availability",
+                "preferences",
+            ]:
                 st.session_state.pop(k, None)
             time.sleep(0.2)
             st.rerun()
 
-# ----- Main Layout -----
+# ---------- Main Layout ----------
 col1, col2 = st.columns([2, 3])
 
-# COMMUNITY PROFILES
+# ---------- Community Profiles ----------
 with col1:
     st.subheader("Community profiles")
     profiles = store.load_all()
+
     if not profiles:
         st.info("No profiles yet.")
     else:
         for p in profiles:
-            cols = st.columns([1, 4])
-            with cols[0]:
+            c1, c2 = st.columns([1, 4])
+
+            with c1:
                 if p.avatar and Path(p.avatar).exists():
                     st.image(p.avatar, width=64)
                 else:
-                    st.image("https://via.placeholder.com/64?text=Avatar", width=64)
-            with cols[1]:
+                    st.image(
+                        "https://via.placeholder.com/64?text=Avatar",
+                        width=64,
+                    )
+
+            with c2:
                 st.markdown(f"**{p.username}**")
                 st.markdown(f"Offers: {', '.join(p.offers) or '—'}")
                 st.markdown(f"Wants: {', '.join(p.wants) or '—'}")
                 st.caption(f"{p.availability} • {p.preferences}")
 
-# AI MATCHMAKING
+# ---------- AI Matchmaking ----------
 with col2:
     st.subheader("Find Matches (AI)")
     profiles = store.load_all()
+
     if not profiles:
         st.info("Add profiles first.")
     else:
-        pick = st.selectbox("Match for profile", [p.username for p in profiles])
-        top_k = 3  # Fixed to 3 matches
+        pick = st.selectbox(
+            "Match for profile",
+            [p.username for p in profiles],
+        )
+
+        top_k = 3
 
         if st.button("Run AI matchmaking"):
             with st.spinner("Finding matches..."):
                 current = store.find_by_username(pick)
-                
+
                 if not current:
                     st.error("Selected profile not found!")
                     st.stop()
 
                 try:
-                    # Try AI matching first
-                    sys_ins, user_msg = make_prompt_for_matching(current, profiles, top_k)
-                    matches = ask_groq_for_matches(sys_ins, user_msg)
-                    
-                    # Ensure matches have score field
-                    for match in matches:
-                        if "score" not in match:
-                            match["score"] = 0
-                except Exception as e:
-                    st.warning(f"AI matching failed: {e}. Using local matching...")
-                    # Fallback to local matching
-                    candidates = [p for p in profiles if p.id != current.id]
-                    matches = calculate_local_matches(current, candidates, top_k)
+                    sys_ins, user_msg = make_prompt_for_matching(
+                        current,
+                        profiles,
+                        top_k,
+                    )
+                    matches = ask_groq_for_matches(
+                        sys_ins,
+                        user_msg,
+                    )
+
+                    for m in matches:
+                        if "score" not in m:
+                            m["score"] = 0
 
-                st.markdown("<div class='card'><b>Top Matches</b></div>", unsafe_allow_html=True)
+                except Exception as e:
+                    st.warning(
+                        f"AI matching failed: {e}. Using local matching..."
+                    )
+                    candidates = [
+                        p for p in profiles if p.id != current.id
+                    ]
+                    matches = calculate_local_matches(
+                        current,
+                        candidates,
+                        top_k,
+                    )
+
+                st.markdown(
+                    "<div class='card'><b>Top Matches</b></div>",
+                    unsafe_allow_html=True,
+                )
 
                 for m in matches:
-                    if not isinstance(m, dict):
-                        continue
-                        
                     c1, c2 = st.columns([1, 5])
+
                     with c1:
                         avatar = m.get("avatar")
                         if avatar and Path(avatar).exists():
                             st.image(avatar, width=72)
                         else:
-                            st.image("https://via.placeholder.com/72?text=User", width=72)
+                            st.image(
+                                "https://via.placeholder.com/72?text=User",
+                                width=72,
+                            )
 
                     with c2:
-                        st.markdown(f"### {m.get('username', 'Unknown User')}")
-                        
-                        # Safely get score with default value
+                        st.markdown(
+                            f"### {m.get('username', 'Unknown User')}"
+                        )
+
                         score = m.get("score", 0)
-                        if not isinstance(score, (int, float)):
-                            try:
-                                score = float(score)
-                            except:
-                                score = 0
+                        try:
+                            score = float(score)
+                        except:
+                            score = 0
+
                         score = max(0, min(100, score))
-                        
-                        st.markdown(f"**Match score:** <span class='match-score'>{score}%</span>", unsafe_allow_html=True)
-                        st.progress(score / 100)
-                        
-                        reason = m.get("reason", "AI matchmaking")
-                        st.caption(f"*{reason}*")
 
-# Feedback button (floating)
-st.markdown("""
-<div class='feedback-floating' onclick="document.querySelector('.feedback-form').style.display='block'">💬</div>
-""", unsafe_allow_html=True)
+                        st.markdown(
+                            f"**Match score:** "
+                            f"<span class='match-score'>{score}%</span>",
+                            unsafe_allow_html=True,
+                        )
+
+                        st.progress(score / 100)
+                        st.caption(
+                            f"*{m.get('reason', 'AI matchmaking')}*"
+                        )
+
+# ---------- Floating Feedback Button ----------
+st.markdown(
+    """
+<div class='feedback-floating'
+     onclick="document.querySelector('.feedback-form').style.display='block'">
+💬
+</div>
+""",
+    unsafe_allow_html=True,
+)
 
-# Hidden feedback form
+# ---------- Feedback ----------
 with st.sidebar:
     st.markdown("---")
     with st.expander("💬 Feedback"):
         feedback = st.text_area("Your feedback")
+
         if st.button("Submit Feedback"):
             if feedback.strip():
-                save_feedback({
-                    "timestamp": time.time(),
-                    "feedback": feedback.strip(),
-                    "username": st.session_state.get("username", "anonymous")
-                })
+                save_feedback(
+                    {
+                        "timestamp": time.time(),
+                        "feedback": feedback.strip(),
+                        "username": st.session_state.get(
+                            "username",
+                            "anonymous",
+                        ),
+                    }
+                )
                 st.success("Thank you for your feedback!")
                 time.sleep(1)
                 st.rerun()
             else:
-                st.warning("Please enter some feedback.")
+                st.warning("Please enter some feedback.")