feat : 개선함

Author: duehee

app/diary/models.py

@@ -21,14 +21,8 @@ class Diary(Base):
 
     user = relationship("User", back_populates="diaries")
     emotion = relationship(EmotionType, back_populates="diaries")
-
-    recommended_songs = relationship(
-        "RecommendedSong",
-        back_populates="diary",
-        cascade="all, delete-orphan",
-        foreign_keys="[RecommendedSong.diary_id]"
-    )
-
+    recommended_songs = relationship("RecommendedSong", back_populates="diary", cascade="all, delete-orphan", foreign_keys="[RecommendedSong.diary_id]")
+    emotion_tags = relationship("DiaryEmotionTag", back_populates="diary", cascade="all, delete-orphan")
 
 class diaryEmbedding(Base):
     __tablename__ = "diaryEmbedding"
@@ -50,6 +44,7 @@ class RecommendedSong(Base):
     album_image = Column(String(512))
     best_lyric = Column(Text)
     similarity_score = Column(Float)
+    youtube_url = Column(String(512), nullable=True)
     created_at = Column(DateTime, default=datetime.utcnow)
 
     # ✅ 어떤 FK를 기준으로 연결할지 명시

app/diary/router.py

@@ -1,8 +1,11 @@
+import os
+
+import requests
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from sqlalchemy import extract, text, func
 from app.database import get_db, get_mongodb, get_redis
-from app.emotion.models import model_index_to_db_emotion_id
+from app.emotion.models import model_index_to_db_emotion_id, DiaryEmotionTag
 from app.emotion.router import predict_emotion
 from app.statistics.models import EmotionStatistics
 from app.user.auth import get_current_user
@@ -11,7 +14,7 @@
     DiaryPreviewResponse, RecommendSongResponse
 from app.user.models import User
 from app.embedding.models import kobert, save_diary_embedding, split_sentences, get_user_preferred_genres, \
-    get_songs_by_genre, get_song_embeddings, calculate_similarity
+    get_songs_by_genre
 from app.transaction import transactional_session
 from typing import List, Set
 import logging
@@ -22,6 +25,7 @@
 from datetime import datetime
 
 router = APIRouter()
+YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY")
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -554,7 +558,7 @@ async def create_diary_with_emotion_based_recommendation(
             1: ["R&B/Soul", "댄스"],
             2: ["인디음악", "R&B/Soul"],
             3: ["R&B/Soul", "인디음악"],
-            4: ["록/메탈", "인디음악"],
+            4: ["R&B/Soul", "인디음악"],
             5: ["발라드", "록/메탈"],
             6: ["발라드", "R&B/Soul"],
             7: ["랩/힙합", "록/메탈"]
@@ -638,7 +642,7 @@ async def create_diary_with_emotion_based_recommendation(
                 }
             ))
 
-        top_3_raw = heapq.nlargest(10, heap, key=lambda x: (x[0], x[1]))
+        top_3_raw = heapq.nlargest(7, heap, key=lambda x: (x[0], x[1]))
 
         recent_lyrics = get_recently_recommended_lyrics(session, user_id=current_user.id)
 
@@ -678,20 +682,43 @@ async def create_diary_with_emotion_based_recommendation(
         session.commit()
         session.refresh(new_diary)
 
+        for eid, score in sorted(emotion_vote_counter.items(), key=lambda x: -x[1])[:3]:
+            avg_score = score / len(sentences)
+            if avg_score >= 0.15:
+                tag = DiaryEmotionTag(
+                    diary_id=new_diary.id,
+                    emotiontype_id=model_index_to_db_emotion_id[eid],
+                    score=round(avg_score, 4)
+                )
+                session.add(tag)
+
         save_diary_embedding(session, new_diary.id, combined_embedding)
 
-        recommended_songs = [
-            {
-                "song_id": match["song_id"],
-                "song_name": match["metadata"]["song_name"],
-                "best_lyric": " ".join(match["lyric_chunk"]),
-                "similarity_score": round(float(sim), 4),
-                "album_image": match["metadata"]["album_image"],
-                "artist": match["metadata"]["artist"],
-                "genre": match["metadata"]["genre"]
-            }
-            for sim, match in top_3
-        ]
+        recommended_songs = []
+        for sim, match in top_3:
+            song_data = RecommendedSong(
+                diary_id=new_diary.id,
+                song_id=match["song_id"],
+                song_name=match["metadata"]["song_name"],
+                artist=match["metadata"]["artist"],
+                genre=match["metadata"]["genre"],
+                album_image=match["metadata"]["album_image"],
+                best_lyric=" ".join(match["lyric_chunk"]),
+                similarity_score=round(float(sim), 4)
+            )
+            session.add(song_data)
+            session.flush()  # ✅ id 부여를 위해 flush
+
+            recommended_songs.append({
+                "id": song_data.id,  # ✅ 여기에 id 포함
+                "song_id": song_data.song_id,
+                "song_name": song_data.song_name,
+                "artist": song_data.artist,
+                "genre": song_data.genre,
+                "album_image": song_data.album_image,
+                "best_lyric": song_data.best_lyric,
+                "similarity_score": song_data.similarity_score,
+            })
 
         for song_data in recommended_songs:
             new_song = RecommendedSong(
@@ -714,6 +741,7 @@ async def create_diary_with_emotion_based_recommendation(
             "content": new_diary.content,
             "emotiontype_id": emotion_id_db,
             "confidence": confidence_full,
+            "best_sentence": new_diary.best_sentence,
             "created_at": new_diary.created_at,
             "updated_at": new_diary.updated_at,
             "recommended_songs": recommended_songs,
@@ -745,6 +773,8 @@ def get_diary(
         RecommendedSong.diary_id == diary.id
     ).order_by(RecommendedSong.similarity_score.desc()).all()
 
+    emotion_tags = db.query(DiaryEmotionTag).filter(DiaryEmotionTag.diary_id == diary.id).all()
+
     main_song = db.query(RecommendedSong).get(diary.main_recommended_song_id)
 
     return DiaryResponse(
@@ -753,9 +783,11 @@ def get_diary(
         content=diary.content,
         emotiontype_id=diary.emotiontype_id,
         confidence=diary.confidence,
+        best_sentence=diary.best_sentence,
         created_at=diary.created_at,
         updated_at=diary.updated_at,
         recommended_songs=recommended_songs,
+        emotion_tags=emotion_tags,
         main_recommend_song=main_song,
         top_emotions=[]
     )
@@ -808,6 +840,7 @@ def get_all_diaries(
             content=diary.content,
             emotiontype_id=diary.emotiontype_id,
             confidence=diary.confidence,
+            best_sentence=diary.best_sentence,
             created_at=diary.created_at,
             updated_at=diary.updated_at,
             recommended_songs=recommended_songs,
@@ -916,17 +949,91 @@ async def set_main_song(
     current_user = Depends(get_current_user),
     db: Session = Depends(get_db)
 ):
-    diary = db.query(Diary).filter(Diary.id == diary_id, Diary.user_id == current_user.id).first()
+    diary = db.query(Diary).filter(
+        Diary.id == diary_id,
+        Diary.user_id == current_user.id
+    ).first()
+
     if not diary:
         raise HTTPException(status_code=404, detail="일기를 찾을 수 없습니다.")
 
     song = db.query(RecommendedSong).filter(
         RecommendedSong.id == recommended_song_id,
         RecommendedSong.diary_id == diary.id
     ).first()
+
     if not song:
         raise HTTPException(status_code=400, detail="추천곡이 일기와 일치하지 않습니다.")
 
+    if not song.youtube_url:
+        query = f"{song.song_name} {' '.join(song.artist)}"
+        api_url = "https://www.googleapis.com/youtube/v3/search"
+        params = {
+            "part": "snippet",
+            "q": query,
+            "type": "video",
+            "maxResults": 1,
+            "key": YOUTUBE_API_KEY
+        }
+
+        res = requests.get(api_url, params=params)
+        data = res.json()
+
+        if not data.get("items"):
+            raise HTTPException(status_code=404, detail="YouTube 영상이 없습니다.")
+
+        video_id = data["items"][0]["id"]["videoId"]
+        song.youtube_url = f"https://www.youtube.com/watch?v={video_id}"
+
+    # 🎯 대표곡 저장
     diary.main_recommended_song_id = song.id
     db.commit()
-    return {"message": "대표 음악이 설정되었습니다."}
+
+    return {
+        "message": "대표 음악이 설정되었습니다.",
+        "youtube_url": song.youtube_url
+    }
+
+@router.get("/recommended-songs/{recommended_song_id}/youtube-link-direct")
+def get_direct_youtube_link(
+    recommended_song_id: int,
+    db: Session = Depends(get_db)
+):
+    song = db.query(RecommendedSong).filter(RecommendedSong.id == recommended_song_id).first()
+    if not song:
+        raise HTTPException(status_code=404, detail="추천곡을 찾을 수 없습니다.")
+
+    # 이미 저장된 경우 → 캐시된 URL 반환
+    if song.youtube_url:
+        return {
+            "recommended_song_id": song.id,
+            "youtube_url": song.youtube_url
+        }
+
+    # YouTube 검색 API 호출
+    query = f"{song.song_name} {' '.join(song.artist)}"
+    api_url = "https://www.googleapis.com/youtube/v3/search"
+    params = {
+        "part": "snippet",
+        "q": query,
+        "type": "video",
+        "maxResults": 1,
+        "key": YOUTUBE_API_KEY
+    }
+
+    res = requests.get(api_url, params=params)
+    data = res.json()
+
+    if not data.get("items"):
+        raise HTTPException(status_code=404, detail="YouTube 영상이 없습니다.")
+
+    video_id = data["items"][0]["id"]["videoId"]
+    youtube_url = f"https://www.youtube.com/watch?v={video_id}"
+
+    song.youtube_url = youtube_url
+    db.commit()
+
+    return {
+        "recommended_song_id": song.id,
+        "youtube_url": youtube_url
+    }

app/diary/schemas.py

@@ -33,6 +33,7 @@ class RecommendSongResponse(BaseModel):
     song_name: str
     artist: List[str]
     genre: str
+    youtube_url: Optional[str] = None
     album_image: str
     best_lyric: str
     similarity_score: float
@@ -46,14 +47,15 @@ class DiaryResponse(BaseModel):
     content: str
     emotiontype_id: Optional[int] = None
     confidence: Optional[float] = None
+    best_sentence: Optional[str] = None  # 추가
     recommended_songs: List[RecommendSongResponse]
     main_recommend_song: Optional[RecommendSongResponse] = None
     top_emotions: list[EmotionScore] = None
     created_at: datetime
     updated_at: datetime
 
     class Config:
-        from_attributes = True  # pydantic v2용 (orm_mode → from_attributes)
+        from_attributes = True
 
 class SentenceEmotion(BaseModel):
     sentence: str
@@ -106,3 +108,9 @@ class EmotionPreviewResponse(BaseModel):
     best_sentence: BestSentence
     sentence_emotions: List[SentenceEmotion]
 
+class EmotionTag(BaseModel):
+    emotiontype_id: int
+    score: float
+
+    class Config:
+        from_attributes = True

app/embedding/models.py

@@ -17,26 +17,30 @@
 SPECIAL_SPLIT_PATTERNS = [
     r"(ㅋ+)", r"(ㅎ+)", r"(ㅠ+)", r"(ㅜ+)",
     r"(\.\.\.+)", r"(ㅡㅡ+)", r"(--+)", r"(;;+)",
-    r"(!+)", r"(\?+)"
+    r"(!+)", r"(\?+)", r"(~+)"
 ]
 
-MIN_SENTENCE_LENGTH = 5
+MIN_SENTENCE_LENGTH = 3
 
 def split_sentences(text: str):
-    """Kiwi + 추가 패턴 기반 문장 분리"""
-    if not text.strip():
-        return []
-
-    # 1차: Kiwi 문장 분리
-    sentences = [s.text for s in kiwi.split_into_sents(text)]
+    # 1차: kiwi로 문장 단위 분리
+    sentences = [s.text.strip() for s in kiwi.split_into_sents(text)]
 
-    refined_sentences = []
-    for sentence in sentences:
-        refined_sentences.extend(split_by_special_patterns(sentence))
+    # 너무 짧은 문장은 다음 문장과 병합
+    refined = []
+    buffer = ""
+    for s in sentences:
+        if len(s) < 5:
+            buffer += " " + s
+        else:
+            if buffer:
+                refined.append(buffer.strip())
+                buffer = ""
+            refined.append(s)
+    if buffer:
+        refined.append(buffer.strip())
 
-    # 공백 제거 및 빈 문자열 제거
-    final_sentences = [s.strip() for s in refined_sentences if s.strip()]
-    return final_sentences
+    return refined
 
 def split_by_special_patterns(sentence: str):
     """특정 감정 표현(ㅋㅋ, ㅠㅠ 등) 주변에서 문장 분리를 시도하되, 짧은 파편은 병합"""

app/emotion/models.py

@@ -2,7 +2,7 @@
 from transformers import BertForSequenceClassification
 from kobert_tokenizer import KoBERTTokenizer
 
-from sqlalchemy import Column, Integer, ForeignKey, String
+from sqlalchemy import Column, Integer, ForeignKey, String, Float
 from sqlalchemy.orm import relationship
 from app.database import Base
 
@@ -32,7 +32,18 @@ class EmotionType(Base):
 
     diaries = relationship("Diary", back_populates="emotion")
 
+class DiaryEmotionTag(Base):
+    __tablename__ = "diaryEmotionTags"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    diary_id = Column(Integer, ForeignKey("diary.id", ondelete="CASCADE"), nullable=False)
+    emotiontype_id = Column(Integer, ForeignKey("emotionType.id", ondelete="CASCADE"), nullable=False)
+    score = Column(Float, nullable=False)
+
+    diary = relationship("Diary", back_populates="emotion_tags")
+    emotion = relationship("EmotionType")
+
 tokenizer = KoBERTTokenizer.from_pretrained("skt/kobert-base-v1")
 model = BertForSequenceClassification.from_pretrained("skt/kobert-base-v1", num_labels=8)
 model.load_state_dict(torch.load("app/emotion/best_model(7th).pt", map_location="cpu"))
-model.eval()
+model.eval()