Create app.py

app.py

@@ -0,0 +1,388 @@
+from __future__ import annotations
+import os
+import json
+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")
+
+# ---------- 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
+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)
+with col_title:
+    st.title("AI Skill Swap — Match & Exchange Skills")
+    st.caption("Connect, Learn, and Grow Together")
+
+store = ProfileStore()
+
+# ----- 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"])
+        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}")
+                with open(avatar_path, "wb") as f:
+                    f.write(avatar_file.getbuffer())
+
+            profile = Profile(
+                id=str(uuid.uuid4()),
+                username=username.strip(),
+                offers=offers,
+                wants=wants,
+                availability=availability.strip(),
+                preferences=preferences.strip(),
+                avatar=avatar_path
+            )
+
+            ok, msg = store.add_or_update(profile)
+            if ok:
+                st.success(msg)
+                st.session_state["username"] = username
+                st.session_state["offers_text"] = offers_text
+                st.session_state["wants_text"] = wants_text
+                st.session_state["availability"] = availability
+                st.session_state["preferences"] = preferences
+            else:
+                st.error(msg)
+
+    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)
+
+    if st.button("Load profile") and selected != "-- new profile --":
+        p = store.find_by_username(selected)
+        if p:
+            st.session_state["username"] = p.username
+            st.session_state["offers_text"] = "\n".join(p.offers)
+            st.session_state["wants_text"] = "\n".join(p.wants)
+            st.session_state["availability"] = p.availability
+            st.session_state["preferences"] = p.preferences
+            st.rerun()
+
+    if st.button("Delete profile") and selected != "-- new profile --":
+        ok, m = store.delete(selected)
+        if ok:
+            st.success(m)
+            for k in ["username","offers_text","wants_text","availability","preferences"]:
+                st.session_state.pop(k, None)
+            time.sleep(0.2)
+            st.rerun()
+
+# ----- Main Layout -----
+col1, col2 = st.columns([2, 3])
+
+# 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]:
+                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.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
+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
+
+        if st.button("Run AI matchmaking"):
+            with st.spinner("Finding matches..."):
+                current = store.find_by_username(pick)
+
+                sys_ins, user_msg = make_prompt_for_matching(current, profiles, top_k)
+                try:
+                    matches = ask_groq_for_matches(sys_ins, user_msg)
+                except:
+                    # fallback local scoring
+                    matches = []
+                    for cand in profiles:
+                        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 and cand.availability.lower() in current.availability.lower():
+                            score += 20
+                        if cand.preferences and current.preferences and cand.preferences.lower() in current.preferences.lower():
+                            score += 20
+
+                        matches.append({
+                            "id": cand.id,
+                            "username": cand.username,
+                            "score": min(100, score),
+                            "reason": "Local scoring",
+                            "avatar": cand.avatar
+                        })
+
+                    matches = sorted(matches, key=lambda x: x["score"], reverse=True)[:top_k]
+
+                st.markdown("<div class='card'><b>Top Matches</b></div>", unsafe_allow_html=True)
+
+                for m in matches:
+                    c1, c2 = st.columns([1, 5])
+                    with c1:
+                        if m.get("avatar") and Path(m["avatar"]).exists():
+                            st.image(m["avatar"], width=72)
+                        else:
+                            st.image("https://via.placeholder.com/72?text=User", width=72)
+
+                    with c2:
+                        st.markdown(f"### {m['username']}")
+                        st.markdown(f"**Match score:** <span class='match-score'>{m['score']}%</span>", unsafe_allow_html=True)
+                        st.progress(int(m["score"]) / 100)
+                        st.markdown("*🎉 Yass! We found a buddy to swap your skills with!*")