Upload 37 files

backend/auth/routes.py

@@ -0,0 +1,175 @@
+from fastapi import APIRouter, HTTPException, Depends, Request, Response
+from fastapi.responses import JSONResponse
+from fastapi.security import OAuth2PasswordRequestForm
+from pydantic import BaseModel, EmailStr
+from datetime import timedelta, timezone, datetime
+import jwt
+from passlib.context import CryptContext
+from db import get_db
+from models import User
+from sqlalchemy.orm import Session
+
+router = APIRouter()
+
+
+class UserSignup(BaseModel):
+    user_name: str
+    user_email: EmailStr
+    password: str
+
+
+users_db = {}
+refresh_tokens = {}
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+SECRET_KEY = "52a6206f34a1c479da043cdeee17fd859a35e54978a6733a6a7ebadcbd11f0ca"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 15
+REFRESH_TOKEN_EXPIRE_DAYS = 7
+
+
+def create_token(data: dict, expires_delta: timedelta = timedelta(minutes=15)):
+    to_encode = data.copy()
+    expire = datetime.now(timezone.utc) + expires_delta  # 권장 방식
+    to_encode.update({"exp": expire})
+    token = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+    return token
+
+
+def verify_token(token: str):
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        email = payload.get("sub")
+        if email is None:
+            raise HTTPException(status_code=401, detail="토큰에 이메일 없음")
+        # 유효한 토큰이고, 사용자 이메일도 있으면 토큰 유효하다고 판단
+        return email
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(status_code=401, detail="토큰 만료")
+    except jwt.PyJWTError:
+        raise HTTPException(status_code=401, detail="토큰 오류")
+
+
+def get_current_user(request: Request):
+    auth_header = request.headers.get("Authorization")
+    if not auth_header or not auth_header.startswith("Bearer "):
+        raise HTTPException(status_code=401, detail="인증 헤더 없음")
+
+    token = auth_header.split(" ")[1]
+    print(token)
+    user = verify_token(token)
+    if not user:
+        raise HTTPException(status_code=401, detail="사용자 없음")
+    return user
+
+
+@router.post("/refresh")
+def refresh_token(request: Request, db: Session = Depends(get_db)):
+    client_refresh_token = request.cookies.get("refresh_token")
+    if not client_refresh_token:
+        raise HTTPException(status_code=401, detail="Refresh token missing")
+
+    try:
+        payload = jwt.decode(client_refresh_token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_email = payload.get("sub")  # or email 등
+        if not user_email:
+            raise HTTPException(status_code=401, detail="Invalid payload")
+
+        # 서버에 저장된 토큰과 비교
+        user = db.query(User).filter(User.user_email == user_email).first()
+        if not user or user.refresh_token != client_refresh_token:
+            raise HTTPException(
+                status_code=401, detail="Token mismatch or reused token"
+            )
+
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(status_code=401, detail="Refresh token expired")
+    except jwt.InvalidTokenError:
+        raise HTTPException(status_code=401, detail="Invalid refresh token")
+
+    # 새 access token 발급
+    new_access_token = create_token(
+        data={"sub": user_email},
+        expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES),
+    )
+
+    return JSONResponse(content={"access_token": new_access_token})
+
+
+@router.post("/logout")
+def logout(request: Request):
+    # 1. 쿠키에서 refresh_token 가져오기
+    refresh_token = request.cookies.get("refresh_token")
+    if not refresh_token:
+        raise HTTPException(status_code=400, detail="Refresh token missing")
+
+    # 2. 서버 측 저장소(DB 또는 in-memory)에서 해당 토큰 삭제
+    # 예: refresh_token_db는 토큰을 저장한 dict
+    try:
+        payload = jwt.decode(refresh_token, SECRET_KEY, algorithms=[ALGORITHM])
+        user_email = payload.get("sub")
+        if refresh_tokens.get(user_email) == refresh_token:
+            del refresh_tokens[user_email]
+    except jwt.PyJWTError:
+        pass
+    res = JSONResponse(content={"message": "Logged out successfully."})
+    # 3. 클라이언트 쿠키에서 제거
+    res.delete_cookie("refresh_token")
+
+    return res
+
+
+@router.post("/login")
+def login(
+    form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)
+):
+    db_user = db.query(User).filter(User.user_email == form_data.username).first()
+    if not db_user:
+        raise HTTPException(status_code=400, detail="Invalid email or password")
+
+    if not pwd_context.verify(form_data.password, db_user.password):
+        raise HTTPException(status_code=400, detail="Invalid email or password")
+    access_token = create_token(
+        data={"sub": db_user.user_email},
+        expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES),
+    )
+    refresh_token = create_token(
+        data={"sub": db_user.user_email},
+        expires_delta=timedelta(days=REFRESH_TOKEN_EXPIRE_DAYS),
+    )
+    db_user.refresh_token = refresh_token
+    db.add(db_user)
+    db.commit()
+    res = JSONResponse(
+        content={
+            "access_token": access_token,
+            "token_type": "bearer",
+        }
+    )
+    res.set_cookie(
+        key="refresh_token",
+        value=refresh_token,
+        httponly=True,
+        secure=False,  # 개발 환경에서는 False 추천
+        samesite="Lax",
+        max_age=60 * 60 * 24,
+    )
+    return res
+
+
+@router.post("/signup")
+def signup(user: UserSignup, db: Session = Depends(get_db)):
+    existing = db.query(User).filter(User.user_email == user.user_email).first()
+
+    if existing:
+        raise HTTPException(status_code=400, detail="Email already registered")
+    hashed_pw = pwd_context.hash(user.password)
+    new_user = User(
+        user_email=user.user_email,
+        user_name=user.user_name,
+        password=hashed_pw,  # 실제로는 해시 후 저장
+    )
+    db.add(new_user)
+    db.commit()
+    return {"message": "User created successfully"}

backend/db.py

@@ -0,0 +1,26 @@
+# db.py
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+import urllib.parse
+
+DB_USER = "root"
+DB_PASSWORD = urllib.parse.quote_plus("wjdals2413@")
+DB_HOST = "localhost"
+DB_PORT = "3306"
+DB_NAME = "gradproject"
+
+DATABASE_URL = f"mysql+pymysql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}?charset=utf8mb4"
+# DATABASE_URL = "mysql://root:oIvlzNQSswVbBwNiTwFsLKdmAbFlLlDx@turntable.proxy.rlwy.net:44568/railway"
+engine = create_engine(DATABASE_URL, echo=True)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

backend/hansepll.py

@@ -0,0 +1,36 @@
+import requests
+import json
+import re
+
+class SpellChecker:
+    def __init__(self):
+        self.passport_key = None
+        self.base_url = None
+
+    def fetch_passport_key(self):
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
+            'Referer': 'https://search.naver.com/',
+        }
+        response = requests.get("https://search.naver.com/search.naver?query=%EB%A7%9E%EC%B6%A9%EB%B2%95%20%EA%B2%80%EC%82%AC%EA%B8%B0", headers=headers)
+        passport_key_match = re.search(r'(?<={new SpellingCheck\({API:{checker:").*?(?="},selector)', response.text)
+        if not passport_key_match:
+            return "Error: Unable to retrieve passport key"
+        self.base_url, self.passport_key = passport_key_match.group(0).split("?passportKey=")
+
+    def spell_check(self, text):
+        if self.passport_key is None or self.base_url is None:
+            self.fetch_passport_key()
+        payload = {
+            'passportKey': self.passport_key,
+            'where': 'nexearch',
+            'color_blindness': 0,
+            'q': text
+        }
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, Gecko) Chrome/129.0.0.0 Safari/537.36',
+            'Referer': 'https://search.naver.com/',
+        }
+        result_response = requests.get(self.base_url, headers=headers, params=payload)
+        return json.loads(result_response.text)['message']['result']['notag_html']
+

backend/hanspell/__init__.py

@@ -0,0 +1 @@
+__version__ = '1.1'

backend/hanspell/constants.py

@@ -0,0 +1,10 @@
+base_url = 'https://m.search.naver.com/p/csearch/ocontent/util/SpellerProxy'
+
+
+class CheckResult:
+    PASSED = 0
+    WRONG_SPELLING = 1
+    WRONG_SPACING = 2
+    AMBIGUOUS = 3
+    STATISTICAL_CORRECTION = 4
+

backend/hanspell/response.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+from collections import namedtuple
+
+# 조사와 어미도 단어로 처리함. 마땅한 영단어가 생각이 안 나서..
+_checked = namedtuple('Checked',
+    ['result', 'original', 'checked', 'errors', 'words', 'time'])
+
+
+class Checked(_checked):
+    def __new__(cls, result=False, original='', checked='', errors=0, words=[], time=0.0):
+        return super(Checked, cls).__new__(
+            cls, result, original, checked, errors, words, time)
+
+    def as_dict(self):
+        d = {
+            'result': self.result,
+            'original': self.original,
+            'checked': self.checked,
+            'errors': self.errors,
+            'words': self.words,
+            'time': self.time,
+        }
+        return d
+
+    def only_checked(self):
+        return self.checked

backend/hanspell/spell_checker.py

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""
+Python용 한글 맞춤법 검사 모듈
+"""
+import re
+import requests
+import json
+import time
+import sys
+from collections import OrderedDict
+import xml.etree.ElementTree as ET
+
+from . import __version__
+from .response import Checked
+from .constants import base_url
+from .constants import CheckResult
+
+_agent = requests.Session()
+PY3 = sys.version_info[0] == 3
+
+
+def get_passport_key():
+    """네이버에서 '네이버 맞춤법 검사기' 페이지에서 passportKey를 획득
+
+        - 네이버에서 '네이버 맞춤법 검사기'를 띄운 후
+        html에서 passportKey를 검색하면 값을 찾을 수 있다.
+
+        - 찾은 값을 spell_checker.py 48 line에 적용한다.
+    """
+
+    url = "https://search.naver.com/search.naver?where=nexearch&sm=top_hty&fbm=0&ie=utf8&query=네이버+맞춤법+검사기"
+    res = requests.get(url)
+
+    html_text = res.text
+
+    match = re.search(r'passportKey=([^&"}]+)', html_text)
+    if match:
+        passport_key = match.group(1)
+        return passport_key
+    else:
+        return False
+
+
+def fix_spell_checker_py_code(file_path, passportKey):
+    """획득한 passportkey를 spell_checker.py파일에 적용
+    """
+
+    pattern = r"'passportKey': '.*'"
+
+    with open(file_path, 'r', encoding='utf-8') as input_file:
+        content = input_file.read()
+        modified_content = re.sub(pattern, f"'passportKey': '{passportKey}'", content)
+
+    with open(file_path, 'w', encoding='utf-8') as output_file:
+        output_file.write(modified_content)
+
+    return
+passport_key = get_passport_key()
+
+def _remove_tags(text):
+    text = u'<content>{}</content>'.format(text).replace('<br>','')
+    if not PY3:
+        text = text.encode('utf-8')
+
+    result = ''.join(ET.fromstring(text).itertext())
+
+    return result
+
+
+def check(text):
+    """
+    매개변수로 입력받은 한글 문장의 맞춤법을 체크합니다.
+    """
+    if isinstance(text, list):
+        result = []
+        for item in text:
+            checked = check(item)
+            result.append(checked)
+        return result
+
+    # 최대 500자까지 가능.
+    if len(text) > 500:
+        return Checked(result=False)
+
+    payload = {
+        "passportKey": passport_key,
+        'color_blindness': '0',
+        'q': text
+    }
+
+    headers = {
+        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36',
+        'referer': 'https://search.naver.com/',
+    }
+
+    start_time = time.time()
+    r = _agent.get(base_url, params=payload, headers=headers)
+    passed_time = time.time() - start_time
+
+    data = json.loads(r.text)
+    html = data['message']['result']['html']
+    result = {
+        'result': True,
+        'original': text,
+        'checked': _remove_tags(html),
+        'errors': data['message']['result']['errata_count'],
+        'time': passed_time,
+        'words': OrderedDict(),
+    }
+
+    # 띄어쓰기로 구분하기 위해 태그는 일단 보기 쉽게 바꿔둠.
+    # ElementTree의 iter()를 써서 더 좋게 할 수 있는 방법이 있지만
+    # 이 짧은 코드에 굳이 그렇게 할 필요성이 없으므로 일단 문자열을 치환하는 방법으로 작성.
+    html = html.replace('<em class=\'green_text\'>', '<green>') \
+               .replace('<em class=\'red_text\'>', '<red>') \
+               .replace('<em class=\'violet_text\'>', '<violet>') \
+               .replace('<em class=\'blue_text\'>', '<blue>') \
+               .replace('</em>', '<end>')
+    items = html.split(' ')
+    words = []
+    tmp = ''
+    for word in items:
+        if tmp == '' and word[:1] == '<':
+            pos = word.find('>') + 1
+            tmp = word[:pos]
+        elif tmp != '':
+            word = u'{}{}'.format(tmp, word)
+        
+        if word[-5:] == '<end>':
+            word = word.replace('<end>', '')
+            tmp = ''
+
+        words.append(word)
+
+    for word in words:
+        check_result = CheckResult.PASSED
+        if word[:5] == '<red>':
+            check_result = CheckResult.WRONG_SPELLING
+            word = word.replace('<red>', '')
+        elif word[:7] == '<green>':
+            check_result = CheckResult.WRONG_SPACING
+            word = word.replace('<green>', '')
+        elif word[:8] == '<violet>':
+            check_result = CheckResult.AMBIGUOUS
+            word = word.replace('<violet>', '')
+        elif word[:6] == '<blue>':
+            check_result = CheckResult.STATISTICAL_CORRECTION
+            word = word.replace('<blue>', '')
+        result['words'][word] = check_result
+
+    result = Checked(**result)
+
+    return result

backend/main.py

@@ -0,0 +1,131 @@
+from fastapi import FastAPI, Depends
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from typing import List, Optional
+from recommendWord import recommendWord
+from fastapi.middleware.cors import CORSMiddleware
+from sentence_transformers import SentenceTransformer
+from keybert import KeyBERT
+from kiwipiepy import Kiwi
+import pandas as pd
+import faiss
+from transformers import AutoTokenizer, AutoModelForMaskedLM
+from ref import refRecommend
+from spellchecker import check
+from auth.routes import router as auth_router
+from auth.routes import get_current_user
+from post_router import router as post_router
+import os
+import requests
+
+FAISS_URL = (
+    "https://huggingface.co/datasets/uuuy5615/my_index/resolve/main/faiss_index.idx"
+)
+CSV_URL = "https://huggingface.co/datasets/uuuy5615/my_index/resolve/main/kci.csv"
+
+FAISS_PATH = "faiss_index.idx"
+CSV_PATH = "kci.csv"
+
+
+def mask_by_position(sentence: str, start: int, end: int) -> str:
+    return sentence[:start] + "[MASK]" + sentence[end:]
+
+
+if not os.path.exists(FAISS_PATH):
+    print("FAISS 파일 다운로드 중...")
+    r = requests.get(FAISS_URL)
+    r.raise_for_status()  # 실패 시 에러 발생
+    with open(FAISS_PATH, "wb") as f:
+        f.write(r.content)
+    print("FAISS 다운로드 완료!")
+
+# CSV 파일 다운로드
+if not os.path.exists(CSV_PATH):
+    print("CSV 파일 다운로드 중...")
+    r = requests.get(CSV_URL)
+    r.raise_for_status()
+    with open(CSV_PATH, "wb") as f:
+        f.write(r.content)
+    print("CSV 다운로드 완료!")
+
+# refrec
+refModel = SentenceTransformer("jhgan/ko-sbert-nli")
+kw_model = KeyBERT(refModel)
+kiwi = Kiwi()
+df = pd.read_csv("kci.csv", low_memory=False)
+index = faiss.read_index("faiss_index.idx")
+
+# wordrec
+tokenizer = AutoTokenizer.from_pretrained("klue/roberta-large")
+wordModel = AutoModelForMaskedLM.from_pretrained("klue/roberta-large")
+
+app = FastAPI()
+
+app.include_router(auth_router, prefix="/auth", tags=["auth"])
+app.include_router(post_router, prefix="/post", tags=["post"])
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://127.0.0.1:5173",
+        "https://geulditbul.vercel.app",
+    ],  # React 앱 주소
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class SpellCheckRequest(BaseModel):
+    text: str
+
+
+class Correction(BaseModel):
+    error: str
+    checked: str
+    position: Optional[int]
+    length: int
+    errortype: int
+
+
+class SpellCheckResponse(BaseModel):
+    flag: int
+    original_text: str
+    checked_text: str
+    corrections: List[Correction]
+    time: float
+
+
+@app.post("/api/spellcheck", response_model=SpellCheckResponse)
+def api_spellcheck(req: SpellCheckRequest, _: dict = Depends(get_current_user)):
+    # check는  dict를 반환
+    return check(req.text)
+
+
+@app.get("/model/WordRec")
+async def runWordRec(
+    user_sentence: str,
+    MaskWord: str,
+    start: int,
+    end: int,
+    _: dict = Depends(get_current_user),
+):
+
+    sentence = mask_by_position(user_sentence, start - 1, end - 1)
+    rec_words = recommendWord(sentence, MaskWord, tokenizer, wordModel)
+
+    # result = {"model_name":model_name, "masked_word": MaskWord, "rec_word" : rec_word}
+
+    # result1, result2, result3 = [rec_word[i:i+3] for i in range(0, len(rec_word), 3)]
+
+    data = {"Model": "WordRec", "masked_word": MaskWord, "rec_result": rec_words}
+
+    return JSONResponse(content=data)
+
+
+@app.get("/model/RefRec")
+async def runRefRec(text: str, _: dict = Depends(get_current_user)):
+    name, link = refRecommend(refModel, kw_model, kiwi, text, df, index)
+    data = {"Model": "RefRec", "name_result": name, "link_result": link}
+
+    return JSONResponse(content=data)

backend/models.py

@@ -0,0 +1,32 @@
+# models.py
+
+from sqlalchemy import Column, Integer, String, Text, DateTime, ForeignKey
+from sqlalchemy.sql import func
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+
+class Post(Base):
+    __tablename__ = "post"
+
+    post_id = Column(Integer, primary_key=True, index=True)
+    title = Column(String(100), nullable=False)
+    content = Column(Text, nullable=True)
+    created_date = Column(DateTime(timezone=True), server_default=func.now())
+    updated_date = Column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now()
+    )
+    user_id = Column(Integer, ForeignKey("user.user_id"), nullable=False)
+
+
+class User(Base):
+    __tablename__ = "user"
+
+    user_id = Column(Integer, primary_key=True, index=True)
+    user_email = Column(String(255), nullable=False, unique=True, index=True)
+    user_name = Column(String(100))
+    password = Column(String(255), nullable=False)
+    join_date = Column(DateTime, default=func.now())
+    last_login_date = Column(DateTime, nullable=True)
+    refresh_token = Column(String(512), nullable=True)

backend/post_router.py

@@ -0,0 +1,119 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from models import Post, User
+from db import get_db
+from pydantic import BaseModel
+from typing import Optional
+from fastapi.security import OAuth2PasswordBearer
+import jwt
+from auth.routes import get_current_user
+
+class PostCreate(BaseModel):
+    title: str
+    content: Optional[str] = None
+
+class PostUpdate(BaseModel):
+    post_id: int
+    title: str
+    content: Optional[str] = None
+
+SECRET_KEY = "52a6206f34a1c479da043cdeee17fd859a35e54978a6733a6a7ebadcbd11f0ca"
+ALGORITHM = "HS256"
+
+router = APIRouter()
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")  # 로그인 경로 설정
+
+
+def get_auth_user(
+    token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)
+) -> User:
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
+        email: str = payload.get("sub")
+        if email is None:
+            raise HTTPException(status_code=401, detail="Token payload invalid")
+    except jwt.PyJWTError:
+        raise HTTPException(status_code=401, detail="Invalid token")
+
+    user = db.query(User).filter(User.user_email == email).first()
+    if user is None:
+        raise HTTPException(status_code=401, detail="User not found")
+
+    return user
+
+
+@router.post("/posts")
+def create_post(
+    post: PostCreate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_auth_user),
+):
+    new_post = Post(
+        title=post.title, content=post.content, user_id=current_user.user_id
+    )
+    db.add(new_post)
+    db.commit()
+    db.refresh(new_post)
+    return {"message": "Post created", "post_id": new_post.post_id}
+
+
+@router.get("/list")
+def get_my_posts(
+    current_user: User = Depends(get_auth_user), db: Session = Depends(get_db)
+):
+    posts = db.query(Post).filter(Post.user_id == current_user.user_id).all()
+    return [{"post_id": post.post_id, "title": post.title} for post in posts]
+
+
+@router.get("/{post_id}")
+def read_user_post(
+    post_id: int,
+    current_user: User = Depends(get_auth_user),
+    db: Session = Depends(get_db),
+):
+    post = (
+        db.query(Post)
+        .filter(Post.post_id == post_id, Post.user_id == current_user.user_id)
+        .first()
+    )
+    if post is None:
+        raise HTTPException(status_code=404, detail="포스트가 없거나 권한이 없습니다.")
+    return {"post_id": post.post_id, "title": post.title, "content": post.content}
+
+@router.put("/save")
+def update_post(
+    post: PostUpdate,
+    db: Session = Depends(get_db),
+    current_user: User = Depends(get_auth_user),
+):
+    db_post = (
+        db.query(Post)
+        .filter(Post.post_id == post.post_id, Post.user_id == current_user.user_id)
+        .first()
+    )
+    if not db_post:
+        raise HTTPException(status_code=404, detail="Post not found or access denied")
+
+    db_post.title = post.title
+    db_post.content = post.content
+    db.commit()
+    db.refresh(db_post)
+
+    return {"message": "Post updated successfully"}
+
+
+@router.delete("/{post_id}")
+def delete_post(
+    post_id: int, db: Session = Depends(get_db), user=Depends(get_auth_user)
+):
+    post = (
+        db.query(Post)
+        .filter(Post.post_id == post_id, Post.user_id == user.user_id)
+        .first()
+    )
+    if not post:
+        raise HTTPException(status_code=404, detail="Post not found")
+    db.delete(post)
+    db.commit()
+    return {"message": "Post deleted"}

backend/recommendWord.py

@@ -0,0 +1,86 @@
+import torch
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import quote
+
+
+def get_synonyms_from_wordsisters(word: str) -> list[str]:
+    encoded_word = quote(word)
+    url = f"https://wordsisters.com/api/ai/{word}"
+    headers = {
+        "User-Agent": "Mozilla/5.0",
+        "Referer": f"https://wordsisters.com/search/{encoded_word}",
+    }
+    try:
+        response = requests.get(url, headers=headers)
+        response.raise_for_status()
+
+        data = response.json()
+        synonyms = data.get("result", {}).get("synonyms", [])
+        return synonyms
+    except Exception as e:
+        print(f"Error fetching synonyms: {e}")
+        return []
+
+
+def extract_synonyms_from_html(html: str) -> list[str]:
+    try:
+        soup = BeautifulSoup(html, "html.parser")
+        synonyms = []
+
+        for tag in soup.select(".link_relate"):
+            text = tag.get_text(strip=True)
+            if text and text not in synonyms:
+                synonyms.append(text)
+
+        print(f"Extracted synonyms: {synonyms}")
+        return synonyms
+    except Exception as e:
+        print(f"Error parsing HTML: {e}")
+        return []
+
+
+def get_synonyms_from_daum(word: str) -> list[str]:
+    try:
+        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
+        params = {"q": word}
+
+        response = requests.get(
+            "https://dic.daum.net/search.do", params=params, headers=headers
+        )
+        response.raise_for_status()
+
+        return extract_synonyms_from_html(response.text)
+    except Exception as e:
+        print(f"Error fetching from Daum: {e}")
+
+
+def max_logit(tensor, symDict, tokenizer):
+    found = []
+    counter = 0
+    size = len(symDict)
+    stop = False
+    for i in range(0, 32000):
+        for j in range(0, size):
+            if str(tokenizer.decode(tensor[1][0][i])) == symDict[j]:
+                found.append(symDict[j])
+                counter += 1
+                break
+        if counter >= 3:
+            break
+    return found
+
+
+def recommendWord(user_sentence, MaskWord, tokenizer, model):
+    inputs = tokenizer(user_sentence, return_tensors="pt")
+    with torch.no_grad():
+        logits = model(**inputs).logits
+    mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(
+        as_tuple=True
+    )[0]
+    symDict = get_synonyms_from_wordsisters(MaskWord)
+    ts = torch.sort(logits[0, mask_token_index], dim=-1, descending=True)
+    found = max_logit(ts, symDict, tokenizer)
+    return found
+
+

backend/ref.py

@@ -0,0 +1,75 @@
+import faiss
+import pandas as pd
+from sentence_transformers import SentenceTransformer
+import math
+from keybert import KeyBERT
+from kiwipiepy import Kiwi
+import urllib.parse
+import json
+
+def safe_int(val):
+    """val이 None 또는 NaN이면 '' 반환, 아니면 int로 변환"""
+    if val is None:
+        return ''
+    if isinstance(val, float) and math.isnan(val):
+        return ''
+    return int(val)
+
+def generate_dbpia_link(title):
+    """논문 제목을 이용해 DBpia 검색 링크 생성"""
+    base_url = "https://www.dbpia.co.kr/search/topSearch?searchOption=all&query="
+    encoded_title = urllib.parse.quote(title)
+    return base_url + encoded_title
+
+def generate_reference(row):
+    """
+    row: 딕셔너리 형태의 논문 정보 (예: DataFrame의 한 행)
+    반환값: 참고문헌 문자열
+    """
+    vol = safe_int(row.get('권'))
+    issue = safe_int(row.get('호'))
+    start_page = safe_int(row.get('시작페이지'))
+    end_page = safe_int(row.get('끝페이지'))
+
+    pages = f"{start_page}-{end_page}" if start_page != '' and end_page != '' else ''
+
+    ref = f"{row.get('저자', '')}. ({safe_int(row.get('발행년'))}). {row.get('논문명(국문)', '')}. {row.get('학술지명(국문)', '')}"
+    
+    if vol != '' or issue != '':
+        issue_str = f"({issue})" if issue != '' else ''
+        ref += f", {vol}{issue_str}"
+    
+    if pages:
+        ref += f", {pages}."
+    else:
+        ref += "."
+
+    link = generate_dbpia_link(row.get('논문명(국문)', ''))
+    return (ref,link)
+
+def refRecommend(model,kw_model,kiwi,text,df,index):
+    nouns_list = []
+    for sentence in kiwi.analyze(text):
+        nouns = [token.form for token in sentence[0] if token.tag.startswith('NN')]
+        if nouns:
+            nouns_list.extend(nouns)
+    result_text = ' '.join(nouns_list)
+
+    keywords = kw_model.extract_keywords(result_text, keyphrase_ngram_range=(1, 1), stop_words=None, top_n=5)
+
+    query_vector = model.encode([keywords[0][0]+" "+keywords[1][0]])
+    D, I = index.search(query_vector, k=3)  # k는 찾고 싶은 개수 (예: top-5)
+
+    results = df.iloc[I[0]]  # I[0]은 top-k 결과의 인덱스 리스트
+
+    name = []
+    link = []
+# 6. 예시 출력
+    for i, row in results.iterrows():
+        name_result,link_result = generate_reference(row)
+        print(name_result)
+        name.append(name_result)
+        link.append(link_result)
+    # print(f"{i+1}. 제목: {row['논문명(국문)']} / 키워드: {row['키워드(국문)']}")
+    # print(f"{row['저자']}. ({row['발행년']}). {row['논문명(국문)']}. {row['학술지명(국문)']}, {int(row['권'])}({int(row['호'])}), {int(row['시작페이지'])}-{int(row['끝페이지'])}")
+    return name,link

backend/requirements.txt

@@ -0,0 +1,20 @@
+beautifulsoup4==4.13.4
+faiss_cpu==1.11.0
+fastapi==0.115.12
+keybert==0.9.0
+kiwipiepy==0.21.0
+pandas==2.2.3
+passlib==1.7.4
+pydantic==2.11.5
+PyJWT==2.10.1
+Requests==2.32.3
+sentence_transformers==4.1.0
+SQLAlchemy==2.0.41
+torch==2.7.0
+transformers==4.51.3
+uvicorn==0.34.3
+mysqlclient
+pydantic[email]
+python-multipart
+bcrypt
+pymysql

backend/spellchecker.py

@@ -0,0 +1,191 @@
+import json
+import difflib
+from hanspell import spell_checker
+from hanspell.constants import CheckResult
+from kiwipiepy import Kiwi
+
+ERROR_TYPE_MAPPING = {
+    CheckResult.PASSED: 0,  # 문제가 없는 단어 또는 구절
+    CheckResult.WRONG_SPELLING: 1,  # 맞춤법에 문제가 있는 단어 또는 구절
+    CheckResult.WRONG_SPACING: 2,  # 띄어쓰기에 문제가 있는 단어 또는 구절
+    CheckResult.AMBIGUOUS: 3,  # 표준어가 의심되는 단어 또는 구절
+    CheckResult.STATISTICAL_CORRECTION: 4,  # 통계적 교정에 따른 단어 또는 구절
+}
+import difflib
+
+
+def update_corrections_by_error_text(original_text, checked_text, corrections):
+    updated = []
+
+    for corr in corrections:
+        error = corr["error"]
+        start_pos = original_text.find(error)
+
+        if start_pos == -1:
+            # error 문장을 못 찾은 경우 position 기반으로 fallback
+            start_pos = corr["position"]
+
+        length = len(error)
+        # checked_text에서 동일 위치 추정
+        corrected_text = checked_text[start_pos : start_pos + length]
+
+        new_corr = corr.copy()
+        new_corr["checked"] = corrected_text
+        new_corr["position"] = start_pos  # 위치 보정
+        new_corr["length"] = length
+        updated.append(new_corr)
+
+    return updated
+
+
+def extract_phrase(text: str, position: int) -> str:
+    if position < 0 or position >= len(text):
+        return ""
+
+    # 왼쪽 탐색: position - 1 부터 공백이 나올 때까지
+    left = position - 1
+    while left >= 0 and text[left] != " ":
+        left -= 1
+
+    # 오른쪽 탐색: position + 1 부터 공백이 나올 때까지
+    right = position + 1
+    while right < len(text) and text[right] != " ":
+        right += 1
+
+    return text[left + 1 : right]
+
+
+def get_space_diffs(original: str, corrected: str):
+    diffs = []
+    orig_len = len(original)
+    corr_len = len(corrected)
+    o_idx = c_idx = 0
+
+    while o_idx < orig_len and c_idx < corr_len:
+        o_char = original[o_idx]
+        c_char = corrected[c_idx]
+
+        # 동일 문자면 통과
+        if o_char == c_char:
+            o_idx += 1
+            c_idx += 1
+            continue
+        # 원문에 공백이 있고 교정문에 없으면 → delete_space
+        if o_char == " " and c_char != " ":
+            error = extract_phrase(original, o_idx)
+            check = spell_checker.check(error).as_dict()["checked"]
+            diffs.append(
+                {
+                    "error": error,
+                    "checked": check,
+                    "position": o_idx,
+                    "length": -1,
+                    "errortype": ERROR_TYPE_MAPPING[2],
+                }
+            )
+            o_idx += 1  # 공백을 넘김
+
+        # 교정문에 공백이 있고 원문에 없으면 → insert_space
+        elif c_char == " " and o_char != " ":
+            # 공백을 그 "앞 문자" 뒤에 삽입한다고 가정
+            error = extract_phrase(original, o_idx)
+            check = spell_checker.check(error).as_dict()["checked"]
+            diffs.append(
+                {
+                    "error": error,
+                    "checked": check,
+                    "position": o_idx,  # 원문 기준 삽입 위치
+                    "length": 1,
+                    "errortype": ERROR_TYPE_MAPPING[2],
+                }
+            )
+            c_idx += 1  # 공백을 넘김
+
+        # 둘 다 다르지만 공백도 아닐 때 (문법 교정 등): 그냥 넘김
+        else:
+            o_idx += 1
+            c_idx += 1
+
+    return diffs
+
+
+def check(text: str):
+    ch_text = spell_checker.check(text)
+    info = ch_text.as_dict()
+    orig_text = info["original"]
+    corr_text = info["checked"]
+    time = info["time"]
+    if orig_text == corr_text:
+        flag = 0
+    else:
+        flag = 1
+    print(info["words"])
+    space = get_space_diffs(orig_text, corr_text)
+    # 1) original↔corrected 간 문자 단위 매핑 생성
+    sm = difflib.SequenceMatcher(None, orig_text, corr_text)
+    mapping = {}
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == "equal":
+            # 일치 블록: 1:1 매핑
+            for offset in range(i2 - i1):
+                mapping[j1 + offset] = i1 + offset
+        elif tag in ("replace", "insert"):
+            # 교체블록·삽입블록: 교정문자 모두 원본 블록 시작 위치로 매핑
+            for offset in range(j2 - j1):
+                mapping[j1 + offset] = i1
+    # 2) 토큰별로 위치 및 원래 틀린 단어 추출
+    corrections = []
+    for token, status in info["words"].items():
+        if status == CheckResult.PASSED or status == CheckResult.WRONG_SPACING:
+            continue
+
+        corr_pos = corr_text.find(token)
+
+        if corr_pos != -1 and corr_pos in mapping:
+            orig_pos = mapping[corr_pos]
+            # 원본 텍스트에서 token 길이만큼 잘라낸다다.
+            error_word = orig_text[orig_pos : orig_pos + len(token)]
+        else:
+            orig_pos = None
+            error_word = token
+        length = len(error_word)
+        corrections.append(
+            {
+                "error": error_word,
+                "checked": token,
+                "position": orig_pos,
+                "length": length,
+                "errortype": ERROR_TYPE_MAPPING[status],
+            }
+        )
+    combined = corrections + space
+
+    sorted_combined = sorted(combined, key=lambda x: x["position"])
+    result = {
+        "flag": flag,
+        "original_text": info["original"],
+        "checked_text": info["checked"],
+        "corrections": sorted_combined,
+        "time": time,
+    }
+
+    return result
+
+
+if __name__ == "__main__":
+    sample = "나는 오늘 아침밥을 먹고 학교 를 갔다.학교 를 아는 친구들이 많치만, 오늘은 별루 보이지 않았다. 학교앞 문구점에서 볼펜을 샀는데, 그 볼펜은 잉크가 자주 말라서 자주 바꿔야한다. 학교에서 학교 행사에 대한 얘기를 들었는데, 별루 기대는 안된다."
+    sample2 = "현대 교육은 단순히 지식을 전달하는 것을 넘어서, 학생의 전인적 성잘을 목표로 한다. 이에 따라 정서적 지지와 사회성 교육도 점점 중요해지고 있있다. 그러나 아직도 많은 학교에서는 주입식 교육이 중심이 되어, 학생들이 주도적으로 학습할 기회가 적다. 또한, 교사들의 과도한 행정업무로 인해 수업 준비에 충분한 시간을 가질수 없고, 이는 교육의 질 저하로 이어질 수 있따. 지속적인 교사 연수와 교육환경 개선이 뒷받침되어야만 미래형 교육이 실현될 수 있슬 것이다."
+    output = check(sample2)
+    print(json.dumps(output, ensure_ascii=False, indent=2))
+    print(sample2[79])
+    # "flag": 문장에 맞춤법 오류가 있는지의 여부(0: 없음/1: 있음)
+    # "original_text": 원본 문장
+    # "checked_text": 맞춤법이 수정된 문장
+    # "corrections"[
+    # {
+    #   "error": 맞춤법이 틀린 단어
+    #   "position": 틀린 단어의 문장 내 위치(시작점)
+    #   "errortype": 오류 유형(1~4)
+    # },
+    # ]
+    # "time": 소요 시간

backend/test.py

@@ -0,0 +1,45 @@
+import requests
+from bs4 import BeautifulSoup
+
+def get_synonyms_from_daum(word: str) -> list[str]:
+    try:
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'
+        }
+        params = {
+            'q': word
+        }
+
+        response = requests.get("https://dic.daum.net/search.do", params=params, headers=headers)
+        response.raise_for_status()
+
+        return extract_synonyms_from_html(response.text)
+    except Exception as e:
+        print(f"Error fetching from Daum: {e}")
+
+def extract_synonyms_from_html(html: str) -> list[str]:
+    try:
+        soup = BeautifulSoup(html, 'html.parser')
+        synonyms = []
+
+        for tag in soup.select('.link_relate'):
+            text = tag.get_text(strip=True)
+            if text and text not in synonyms:
+                synonyms.append(text)
+
+        print(f"Extracted synonyms: {synonyms}")
+        return synonyms
+    except Exception as e:
+        print(f"Error parsing HTML: {e}")
+        return []
+
+
+# 예시 사용
+
+# word = "능력"
+# synonyms = get_synonyms_from_daum(word)
+def mask_by_position(sentence: str, start: int, end: int) -> str:
+    return sentence[:start-1] + "[MASK]" + sentence[end-1:]
+
+# a = mask_by_position("각자가 업무를 하면서 개인의 능력으로 모든 일을 해결할 수 있다면 정말 기쁠 것입니다",17,19)
+# print(a)

dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9.13
+
+WORKDIR /app
+
+# backend 폴더 전체 복사
+COPY backend/ ./backend
+
+# backend 안의 requirements.txt 설치
+RUN pip install --no-cache-dir -r backend/requirements.txt
+
+# (필요하면 startup.py 복사)
+
+CMD ["bash", "-c", "uvicorn backend.main:app --host 0.0.0.0 --port 7860"]