';
(rep.reorders||[]).forEach(function(ro){
var firstPoi=(ro.suggested_order||[])[0];
html+='
'+
diff --git a/src/data/barrier_free_api.py b/src/data/barrier_free_api.py
index c910da1..2928ae6 100644
--- a/src/data/barrier_free_api.py
+++ b/src/data/barrier_free_api.py
@@ -6,6 +6,7 @@
참고: 한국관광공사_개방데이터_활용매뉴얼(무장애여행)_v4.3
"""
+
from __future__ import annotations
from dataclasses import dataclass
@@ -16,32 +17,34 @@
from src.data.models import Settings
_BASE_URL = "https://apis.data.go.kr/B551011/KorWithService2"
-_LIST_OP = "areaBasedList2" # 지역기반 목록 조회
-_DETAIL_OP = "detailWithTour2" # 무장애여행 상세 조회
+_LIST_OP = "areaBasedList2" # 지역기반 목록 조회
+_DETAIL_OP = "detailWithTour2" # 무장애여행 상세 조회
@dataclass(frozen=True)
class BarrierFreePlace:
"""areaBasedList2 기반 기본 POI + detailWithTour2 접근성 세부 항목."""
+
content_id: str
title: str
addr: str
- lat: float # mapy (WGS84 위도)
- lng: float # mapx (WGS84 경도)
+ lat: float # mapy (WGS84 위도)
+ lng: float # mapx (WGS84 경도)
# ── detailWithTour2 지체장애 항목 (선택 보강) ──────────────────
- wheelchair: str = "" # 휠체어 대여/접근 여부 (텍스트, 예: "대여가능(수동휠체어 2대)")
- elevator: str = "" # 엘리베이터 여부 (텍스트)
- parking: str = "" # 장애인 주차 여부 (텍스트)
+ wheelchair: str = "" # 휠체어 대여/접근 여부 (텍스트, 예: "대여가능(수동휠체어 2대)")
+ elevator: str = "" # 엘리베이터 여부 (텍스트)
+ parking: str = "" # 장애인 주차 여부 (텍스트)
# ── detailWithTour2 영유아가족 항목 ─────────────────────────────
- stroller: str = "" # 유모차 여부 (텍스트)
+ stroller: str = "" # 유모차 여부 (텍스트)
lactation_room: str = "" # 수유실 여부 (텍스트)
# ── detailWithTour2 시각장애 항목 ───────────────────────────────
- help_dog: str = "" # 보조견 동반 여부 (텍스트)
+ help_dog: str = "" # 보조견 동반 여부 (텍스트)
@dataclass(frozen=True)
class BarrierFreeDetail:
"""detailWithTour2 응답 전체 필드 (필요 시 개별 조회용)."""
+
content_id: str
# 지체장애
parking: str = ""
@@ -101,7 +104,7 @@ def __init__(self, api_key: str, timeout_sec: float = 10.0) -> None:
self._timeout = timeout_sec
@classmethod
- def from_settings(cls, settings: Settings | None = None) -> "BarrierFreeAPIClient | None":
+ def from_settings(cls, settings: Settings | None = None) -> BarrierFreeAPIClient | None:
if settings is None:
settings = Settings()
key = settings.barrier_free_api_key
@@ -151,13 +154,15 @@ async def fetch_page(
lng = _safe_float(item.get("mapx") or item.get("lng"))
if not content_id or lat == 0.0 or lng == 0.0:
continue
- places.append(BarrierFreePlace(
- content_id=content_id,
- title=title,
- addr=addr,
- lat=lat,
- lng=lng,
- ))
+ places.append(
+ BarrierFreePlace(
+ content_id=content_id,
+ title=title,
+ addr=addr,
+ lat=lat,
+ lng=lng,
+ )
+ )
return places
async def fetch_detail(self, content_id: str) -> BarrierFreeDetail | None:
diff --git a/src/data/dwell_db.py b/src/data/dwell_db.py
index e942df6..3df655c 100644
--- a/src/data/dwell_db.py
+++ b/src/data/dwell_db.py
@@ -9,6 +9,7 @@
사용자가 입력한 stay_duration이 권장 min의 50% 미만이면 비현실적으로 짧은 일정으로 간주.
"""
+
from __future__ import annotations
from dataclasses import dataclass
@@ -20,6 +21,7 @@
@dataclass(frozen=True)
class DwellRecommendation:
"""권장 체류시간 (분 단위)."""
+
min_minutes: int
max_minutes: int
source: DwellSource
@@ -106,25 +108,25 @@ def is_too_short(self, user_minutes: int, ratio: float = 0.5) -> bool:
"NA0101": (180, 480), # 국립공원
"NA0201": (120, 360), # 도립공원
"NA0401": (180, 480), # 산
- "NA0501": (90, 180), # 자연생태관광지
+ "NA0501": (90, 180), # 자연생태관광지
"NA0601": (120, 240), # 자연휴양림
- "NA0701": (90, 150), # 수목원
- "NA0801": (45, 90), # 폭포
- "NA0901": (60, 120), # 계곡
- "NA1101": (60, 120), # 해안절경
- "NA1201": (90, 240), # 해수욕장
+ "NA0701": (90, 150), # 수목원
+ "NA0801": (45, 90), # 폭포
+ "NA0901": (60, 120), # 계곡
+ "NA1101": (60, 120), # 해안절경
+ "NA1201": (90, 240), # 해수욕장
"NA1301": (240, 480), # 섬
# 인문관광지 (VE)
- "VE0101": (90, 180), # 박물관
- "VE0201": (60, 120), # 기념관
- "VE0301": (60, 120), # 전시관
- "VE0401": (90, 180), # 미술관
- "VE0501": (90, 180), # 체험관
- "VE0701": (60, 120), # 기타문화시설
+ "VE0101": (90, 180), # 박물관
+ "VE0201": (60, 120), # 기념관
+ "VE0301": (60, 120), # 전시관
+ "VE0401": (90, 180), # 미술관
+ "VE0501": (90, 180), # 체험관
+ "VE0701": (60, 120), # 기타문화시설
# 역사관광지 (HS)
- "HS0101": (90, 150), # 고궁
- "HS0201": (60, 120), # 사찰
- "HS0301": (60, 120), # 유적지
+ "HS0101": (90, 150), # 고궁
+ "HS0201": (60, 120), # 사찰
+ "HS0301": (60, 120), # 유적지
# 레포츠 (EX)
"EX0101": (180, 360), # 육상레포츠
"EX0201": (120, 240), # 수상레포츠
@@ -132,45 +134,45 @@ def is_too_short(self, user_minutes: int, ratio: float = 0.5) -> bool:
"EX0401": (240, 480), # 복합레포츠
"EX2101": (300, 600), # 테마파크 (추정 코드)
# 음식점 (FD)
- "FD0101": (45, 75), # 한식
- "FD0102": (45, 75), # 양식
- "FD0103": (45, 75), # 일식
- "FD0104": (45, 75), # 중식
- "FD0201": (30, 60), # 카페
- "FD0202": (30, 60), # 카페·전통찻집
+ "FD0101": (45, 75), # 한식
+ "FD0102": (45, 75), # 양식
+ "FD0103": (45, 75), # 일식
+ "FD0104": (45, 75), # 중식
+ "FD0201": (30, 60), # 카페
+ "FD0202": (30, 60), # 카페·전통찻집
# 쇼핑 (SH)
- "SH0101": (45, 90), # 5일장·전통시장
- "SH0201": (60, 180), # 백화점
- "SH0301": (60, 120), # 면세점
- "SH0401": (60, 120), # 대형마트
+ "SH0101": (45, 90), # 5일장·전통시장
+ "SH0201": (60, 180), # 백화점
+ "SH0301": (60, 120), # 면세점
+ "SH0401": (60, 120), # 대형마트
# 숙박 (AC) — depot이라 체류시간 의미 없음, 형식상 정의
- "AC0101": (0, 0), # 호텔
- "AC0301": (0, 0), # 한옥
+ "AC0101": (0, 0), # 호텔
+ "AC0301": (0, 0), # 한옥
}
# ── 3순위: lclsSystm1 (1-depth 대분류) 기반 ──────────────────────────
BY_LCLS1: dict[str, tuple[int, int]] = {
- "NA": (90, 240), # 자연관광지
- "VE": (75, 150), # 인문관광지
- "HS": (60, 120), # 역사관광지
+ "NA": (90, 240), # 자연관광지
+ "VE": (75, 150), # 인문관광지
+ "HS": (60, 120), # 역사관광지
"EX": (180, 360), # 레포츠
- "FD": (45, 75), # 음식점
- "SH": (60, 120), # 쇼핑
- "AC": (0, 0), # 숙박
+ "FD": (45, 75), # 음식점
+ "SH": (60, 120), # 쇼핑
+ "AC": (0, 0), # 숙박
}
# ── 4순위: contentTypeId 기반 ─────────────────────────────────────────
BY_CONTENT_TYPE: dict[int, tuple[int, int]] = {
- 12: (90, 150), # 관광지
- 14: (90, 150), # 문화시설
- 15: (120, 240), # 축제공연행사
- 25: (480, 720), # 여행코스 (하루 단위)
- 28: (180, 360), # 레포츠
- 32: (0, 0), # 숙박
- 38: (60, 120), # 쇼핑
- 39: (45, 75), # 음식점
+ 12: (90, 150), # 관광지
+ 14: (90, 150), # 문화시설
+ 15: (120, 240), # 축제공연행사
+ 25: (480, 720), # 여행코스 (하루 단위)
+ 28: (180, 360), # 레포츠
+ 32: (0, 0), # 숙박
+ 38: (60, 120), # 쇼핑
+ 39: (45, 75), # 음식점
}
diff --git a/src/data/evidence_retriever.py b/src/data/evidence_retriever.py
new file mode 100644
index 0000000..ac8e22b
--- /dev/null
+++ b/src/data/evidence_retriever.py
@@ -0,0 +1,94 @@
+"""로컬 장소 근거 리트리버.
+
+검증 요청이 외부 그래프 서버에 의존하지 않도록 배포물의 장소 CSV를 인덱싱한다.
+장소 검색과 좌표 기반 근접 대안 조회를 같은 데이터 레이어에서 제공한다.
+"""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+
+from src.data.models import AlternativePOI, PlaceEvidence
+from src.utils.geo import haversine_km
+
+_PROJECT_ROOT = Path(__file__).resolve().parents[2]
+_DEFAULT_CSV = _PROJECT_ROOT / "data" / "jeju_places.csv"
+
+
+class LocalEvidenceRetriever:
+ """장소명 검색과 근접 대안 조회를 제공하는 로컬 리트리버."""
+
+ def __init__(self, catalog_path: str | Path | None = None) -> None:
+ self._catalog_path = Path(catalog_path or _DEFAULT_CSV)
+ self._places = self._load_places()
+ self._by_id = {place.place_id: place for place in self._places}
+ self.enabled = bool(self._places)
+
+ def _load_places(self) -> list[PlaceEvidence]:
+ if not self._catalog_path.exists():
+ return []
+ places: list[PlaceEvidence] = []
+ try:
+ with self._catalog_path.open(encoding="utf-8-sig", newline="") as file:
+ for row in csv.DictReader(file):
+ try:
+ name = (row.get("상호명") or row.get("name") or "").strip()
+ if not name:
+ continue
+ address = (row.get("도로명주소") or row.get("address") or "").strip()
+ places.append(
+ PlaceEvidence(
+ place_id=(row.get("ID") or row.get("id") or name).strip(),
+ name=name,
+ place_type=(
+ row.get("대분류") or row.get("place_type") or ""
+ ).strip(),
+ category_name=(
+ row.get("중분류명") or row.get("카테고리") or ""
+ ).strip(),
+ region_name=" ".join(address.split()[:2]),
+ address=address,
+ lat=float(row.get("위도") or row.get("lat") or 0),
+ lng=float(row.get("경도") or row.get("lng") or 0),
+ )
+ )
+ except (TypeError, ValueError):
+ continue
+ except (OSError, UnicodeError):
+ return []
+ return places
+
+ @classmethod
+ def from_settings(cls, catalog_path: str | Path | None = None) -> LocalEvidenceRetriever:
+ """설정 기반 생성자. 외부 환경변수나 네트워크를 읽지 않는다."""
+ return cls(catalog_path=catalog_path)
+
+ def search_places(self, query: str, limit: int = 5) -> list[PlaceEvidence]:
+ query = (query or "").strip().casefold()
+ if not query or limit <= 0:
+ return []
+ matches = [place for place in self._places if query in place.name.casefold()]
+ return sorted(
+ matches,
+ key=lambda place: (place.name.casefold() != query, len(place.name)),
+ )[:limit]
+
+ def find_nearby(self, place_id: str, limit: int = 5) -> list[AlternativePOI]:
+ origin = self._by_id.get(place_id)
+ if origin is None or limit <= 0:
+ return []
+ candidates = [place for place in self._places if place.place_id != place_id]
+ candidates.sort(
+ key=lambda place: haversine_km(origin.lat, origin.lng, place.lat, place.lng)
+ )
+ return [
+ AlternativePOI(
+ name=place.name,
+ distance_km=round(haversine_km(origin.lat, origin.lng, place.lat, place.lng), 3),
+ category=place.category_name,
+ lat=place.lat,
+ lng=place.lng,
+ )
+ for place in candidates[:limit]
+ ]
diff --git a/src/data/graph_retriever.py b/src/data/graph_retriever.py
deleted file mode 100644
index e0237da..0000000
--- a/src/data/graph_retriever.py
+++ /dev/null
@@ -1,131 +0,0 @@
-"""Neo4j 지식그래프 리트리버 — Place/Region/NEAR_BY 그래프에서 근거 조회.
-
-scripts/build_knowledge_graph.py + scripts/load_knowledge_graph_neo4j.py로 적재한
-제주도 그래프(Aura)에서 장소명으로 검색하고, 도보 근접 대체 후보를 조회한다.
-explain 엔진이 답변에 인용할 그라운딩 소스.
-
-CLAUDE.md 규칙:
- - 외부 I/O는 data 레이어에서만 처리한다.
- - 키는 환경변수로만 관리한다.
- - 모듈 간 데이터는 Pydantic 모델(PlaceEvidence, AlternativePOI)로만 주고받는다.
-"""
-from __future__ import annotations
-
-import os
-import time
-
-from neo4j import GraphDatabase
-from neo4j.exceptions import DriverError, Neo4jError
-
-from src.data.models import AlternativePOI, PlaceEvidence
-
-_UNREACHABLE_COOLDOWN_SEC = 60.0
-
-_SEARCH_CYPHER = """
-MATCH (p:Place)
-WHERE toLower(p.name) CONTAINS toLower($q)
-OPTIONAL MATCH (p)-[:IS_LOCATED_IN]->(r:Region)
-RETURN p.id AS id, p.name AS name, p.place_type AS place_type,
- p.category_medium_name AS category_name, p.address AS address,
- p.lat AS lat, p.lng AS lng, r.name AS region_name
-ORDER BY toLower(p.name) <> toLower($q), size(p.name)
-LIMIT $limit
-"""
-
-_NEARBY_CYPHER = """
-MATCH (p:Place {id: $place_id})-[rel:NEAR_BY]->(n:Place)
-RETURN n.name AS name, n.category_medium_name AS category,
- n.lat AS lat, n.lng AS lng, rel.distance_m AS distance_m
-ORDER BY rel.distance_m
-LIMIT $limit
-"""
-
-
-class GraphRetriever:
- """제주 지식그래프(Neo4j Aura) 리트리버. 미설정/연결 실패 시 빈 결과로 폴백."""
-
- def __init__(self, uri: str, username: str, password: str, database: str = "neo4j") -> None:
- self._database = database
- self._driver = (
- GraphDatabase.driver(
- uri,
- auth=(username, password),
- connection_timeout=5.0,
- max_transaction_retry_time=5.0,
- )
- if uri
- else None
- )
- self._unreachable_until = 0.0
-
- @classmethod
- def from_env(cls) -> GraphRetriever:
- return cls(
- uri=os.environ.get("NEO4J_URI", ""),
- username=os.environ.get("NEO4J_USERNAME", ""),
- password=os.environ.get("NEO4J_PASSWORD", ""),
- database=os.environ.get("NEO4J_DATABASE", "neo4j"),
- )
-
- @property
- def enabled(self) -> bool:
- return self._driver is not None
-
- def _callable(self) -> bool:
- """호출 가능 여부. 최근 연결 실패 시 쿨다운 동안 재시도 백오프 비용 없이 즉시 빈 결과로 넘긴다."""
- return self.enabled and time.monotonic() >= self._unreachable_until
-
- def _mark_unreachable(self) -> None:
- self._unreachable_until = time.monotonic() + _UNREACHABLE_COOLDOWN_SEC
-
- def close(self) -> None:
- if self._driver is not None:
- self._driver.close()
-
- def search_places(self, query: str, limit: int = 5) -> list[PlaceEvidence]:
- """장소명 부분일치 검색 — Region 컨텍스트 포함."""
- q = (query or "").strip()
- if not q or not self._callable():
- return []
- try:
- result = self._driver.execute_query(
- _SEARCH_CYPHER, q=q, limit=limit, database_=self._database
- )
- except (Neo4jError, DriverError):
- self._mark_unreachable()
- return []
- return [
- PlaceEvidence(
- place_id=rec["id"],
- name=rec["name"],
- place_type=rec["place_type"] or "",
- category_name=rec["category_name"] or "",
- region_name=rec["region_name"] or "",
- address=rec["address"] or "",
- lat=rec["lat"],
- lng=rec["lng"],
- )
- for rec in result.records
- ]
-
- def find_nearby(self, place_id: str, limit: int = 5) -> list[AlternativePOI]:
- """NEAR_BY 그래프에서 도보 근접 대체 후보 조회 (거리순)."""
- if not place_id or not self._callable():
- return []
- try:
- result = self._driver.execute_query(
- _NEARBY_CYPHER, place_id=place_id, limit=limit, database_=self._database
- )
- except (Neo4jError, DriverError):
- self._mark_unreachable()
- return []
- return [
- AlternativePOI(
- name=rec["name"],
- distance_km=round(rec["distance_m"] / 1000, 3),
- category=rec["category"] or "",
- lat=rec["lat"],
- lng=rec["lng"],
- )
- for rec in result.records
- ]
diff --git a/src/data/hours_db.py b/src/data/hours_db.py
index 3cd10d8..9f015b2 100644
--- a/src/data/hours_db.py
+++ b/src/data/hours_db.py
@@ -5,7 +5,9 @@
spec = resolve_hours("경복궁", "관광지")
# spec.open_, spec.close_, spec.off_days, spec.break_start, spec.break_end
"""
+
from __future__ import annotations
+
import re
from dataclasses import dataclass, field
@@ -16,229 +18,337 @@ class HoursSpec:
open_: str
close_: str
break_start: str | None = None
- break_end: str | None = None
- off_days: list[int] = field(default_factory=list) # 0=월, ..., 6=일
+ break_end: str | None = None
+ off_days: list[int] = field(default_factory=list) # 0=월, ..., 6=일
# ── 카테고리 표준값 (category_hours.xlsx 와 동기화) ──────────
SUB_CATEGORIES: dict[str, HoursSpec] = {
"nature_outdoor": HoursSpec(
- label='자연 · 산·해변·공원',
- open_='00:00', close_='23:59',
- break_start=None, break_end=None,
+ label="자연 · 산·해변·공원",
+ open_="00:00",
+ close_="23:59",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"palace": HoursSpec(
- label='궁궐 · 종묘',
- open_='09:00', close_='18:00',
- break_start=None, break_end=None,
+ label="궁궐 · 종묘",
+ open_="09:00",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[1],
),
"tomb_historic": HoursSpec(
- label='왕릉 · 유적지 · 성곽',
- open_='09:00', close_='18:00',
- break_start=None, break_end=None,
+ label="왕릉 · 유적지 · 성곽",
+ open_="09:00",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[0],
),
"temple": HoursSpec(
- label='사찰 · 사찰림',
- open_='04:00', close_='19:00',
- break_start=None, break_end=None,
+ label="사찰 · 사찰림",
+ open_="04:00",
+ close_="19:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"traditional_village": HoursSpec(
- label='한옥마을 · 민속촌',
- open_='09:00', close_='18:00',
- break_start=None, break_end=None,
+ label="한옥마을 · 민속촌",
+ open_="09:00",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"street_plaza": HoursSpec(
- label='거리 · 광장 · 골목',
- open_='00:00', close_='23:59',
- break_start=None, break_end=None,
+ label="거리 · 광장 · 골목",
+ open_="00:00",
+ close_="23:59",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"market_traditional": HoursSpec(
- label='전통시장',
- open_='09:00', close_='21:00',
- break_start=None, break_end=None,
+ label="전통시장",
+ open_="09:00",
+ close_="21:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"market_seafood": HoursSpec(
- label='수산시장',
- open_='04:00', close_='21:00',
- break_start=None, break_end=None,
+ label="수산시장",
+ open_="04:00",
+ close_="21:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"night_market": HoursSpec(
- label='야시장',
- open_='18:00', close_='23:00',
- break_start=None, break_end=None,
+ label="야시장",
+ open_="18:00",
+ close_="23:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"tower_observatory": HoursSpec(
- label='타워 · 전망대',
- open_='10:00', close_='22:00',
- break_start=None, break_end=None,
+ label="타워 · 전망대",
+ open_="10:00",
+ close_="22:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"museum": HoursSpec(
- label='박물관 · 미술관 · 기념관',
- open_='10:00', close_='18:00',
- break_start=None, break_end=None,
+ label="박물관 · 미술관 · 기념관",
+ open_="10:00",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[0],
),
"library_culture_center": HoursSpec(
- label='도서관 · 문화회관',
- open_='09:00', close_='21:00',
- break_start=None, break_end=None,
+ label="도서관 · 문화회관",
+ open_="09:00",
+ close_="21:00",
+ break_start=None,
+ break_end=None,
off_days=[0],
),
"theme_park": HoursSpec(
- label='테마파크 · 놀이공원',
- open_='10:00', close_='22:00',
- break_start=None, break_end=None,
+ label="테마파크 · 놀이공원",
+ open_="10:00",
+ close_="22:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"aquarium_zoo": HoursSpec(
- label='수족관 · 동물원',
- open_='09:30', close_='18:00',
- break_start=None, break_end=None,
+ label="수족관 · 동물원",
+ open_="09:30",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"korean_restaurant": HoursSpec(
- label='한식당',
- open_='11:00', close_='21:30',
- break_start='15:00', break_end='17:00',
+ label="한식당",
+ open_="11:00",
+ close_="21:30",
+ break_start="15:00",
+ break_end="17:00",
off_days=[],
),
"bbq_restaurant": HoursSpec(
- label='고기집 · 바비큐',
- open_='11:30', close_='23:00',
- break_start=None, break_end=None,
+ label="고기집 · 바비큐",
+ open_="11:30",
+ close_="23:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"noodle_restaurant": HoursSpec(
- label='면 · 분식',
- open_='10:30', close_='21:00',
- break_start=None, break_end=None,
+ label="면 · 분식",
+ open_="10:30",
+ close_="21:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"general_restaurant": HoursSpec(
- label='일반 식당',
- open_='11:00', close_='21:00',
- break_start='15:00', break_end='17:00',
+ label="일반 식당",
+ open_="11:00",
+ close_="21:00",
+ break_start="15:00",
+ break_end="17:00",
off_days=[],
),
"cafe": HoursSpec(
- label='카페 · 디저트',
- open_='09:00', close_='22:00',
- break_start=None, break_end=None,
+ label="카페 · 디저트",
+ open_="09:00",
+ close_="22:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"bakery": HoursSpec(
- label='베이커리',
- open_='08:00', close_='21:00',
- break_start=None, break_end=None,
+ label="베이커리",
+ open_="08:00",
+ close_="21:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"department_store": HoursSpec(
- label='백화점 · 쇼핑몰',
- open_='10:30', close_='20:00',
- break_start=None, break_end=None,
+ label="백화점 · 쇼핑몰",
+ open_="10:30",
+ close_="20:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"outlet": HoursSpec(
- label='아울렛',
- open_='10:30', close_='21:00',
- break_start=None, break_end=None,
+ label="아울렛",
+ open_="10:30",
+ close_="21:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"leisure_sport": HoursSpec(
- label='레포츠 · 체험',
- open_='09:00', close_='18:00',
- break_start=None, break_end=None,
+ label="레포츠 · 체험",
+ open_="09:00",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"lodging": HoursSpec(
- label='숙박',
- open_='00:00', close_='23:59',
- break_start=None, break_end=None,
+ label="숙박",
+ open_="00:00",
+ close_="23:59",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"religious_site": HoursSpec(
- label='성당 · 교회',
- open_='06:00', close_='21:00',
- break_start=None, break_end=None,
+ label="성당 · 교회",
+ open_="06:00",
+ close_="21:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"scenic_spot": HoursSpec(
- label='명승지 · 절경',
- open_='00:00', close_='23:59',
- break_start=None, break_end=None,
+ label="명승지 · 절경",
+ open_="00:00",
+ close_="23:59",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"cave": HoursSpec(
- label='동굴 (관광)',
- open_='09:00', close_='18:00',
- break_start=None, break_end=None,
+ label="동굴 (관광)",
+ open_="09:00",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"cable_car": HoursSpec(
- label='케이블카 · 모노레일',
- open_='09:00', close_='18:00',
- break_start=None, break_end=None,
+ label="케이블카 · 모노레일",
+ open_="09:00",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"ranch_farm": HoursSpec(
- label='목장 · 체험농장',
- open_='09:00', close_='18:00',
- break_start=None, break_end=None,
+ label="목장 · 체험농장",
+ open_="09:00",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
"default_attraction": HoursSpec(
- label='기타 관광지 (미분류)',
- open_='09:00', close_='18:00',
- break_start=None, break_end=None,
+ label="기타 관광지 (미분류)",
+ open_="09:00",
+ close_="18:00",
+ break_start=None,
+ break_end=None,
off_days=[],
),
}
# ── 키워드 → sub_category 매칭 룰 (위에서 아래로 평가) ───────
KEYWORD_RULES: list[tuple[str, str]] = [
- ('봉은사|해동용궁사|불국사|석굴암|낙산사|월정사|향일암|선암사|구인사|마곡사|전등사|진관사|용궁사|부석사|보리암|쌍계사|선운사|용문사|해인사|통도사|범어사|송광사|법주사|미황사|화엄사|쌍봉사|운주사|금산사|내장사|관음사|약천사|약사사|봉정사|봉선사|적천사|자장사|봉선사|동학사|갑사|마이산탑사|청룡사|봉선사|관룡사|사불산|불교문화관', 'temple'),
- ('만장굴|고씨굴|천지연.*동굴|화암동굴|단양고수동굴|고수동굴|환선굴|여천굴|동굴$|관광동굴|대금굴|해저터널|관광터널', 'cave'),
- ('케이블카|모노레일|곤돌라|로프웨이|루지$|짚라인|집라인|레일바이크', 'cable_car'),
- ('목장|양떼목장|허브농장|농원$|체험농장|승마장', 'ranch_farm'),
- ('산$|^[가-힣]+산\\s|산림욕|봉우리|봉$|폭포|계곡|숲$|호수|호$|강$|바다|해수욕장|해변$|해안|해변로|해돋이|일출|일몰|만$|곶$|섬$|비치$|^.+도$|^오동도|^외도|^청산도|^보길도|^외연도|^안면도|^거문도|^월미도|^남이섬|공원|숲길|올레|둘레길|등산로|언덕|고개|평원|벌판|초원|꽃밭|들꽃|수목원|식물원|지질공원|자연휴양림|휴양림|자연공원|국립공원|도립공원|가든|편백|편백숲|핀크스|메타세콰이어|소쇄원|죽녹원|관방제림|보성녹차밭|녹차밭|식물원|저수지$|^.+호$|의림지|화진포|두물머리|세미원|태화강국가정원|방조림|어부림|^.+림$|불광천|청계천|^.+천$|동촌유원지|유원지$', 'nature_outdoor'),
- ('낙화암|외돌개|주상절리|정방폭포|천지연|용두암|섭지코지|성산일출봉|비자림|사려니숲|에코랜드|카멜리아힐|선유도|영금정|공지천|경포대|정동진|월정리|함덕|애월|순천만습지|순천만|우포늪|화담숲|아침고요|남이섬|쁘띠프랑스|대왕암|간절곶|호미곶|가천다랭이|용궁리|섭지|올레길|둘레길|태종대|갓바위|신선대|촛대바위|하조대|화진포|정선아우라지|탄금대|통일전망대|묵호항|구룡포항|항구$', 'scenic_spot'),
- ('경복궁|창덕궁|창경궁|덕수궁|경희궁|운현궁|종묘', 'palace'),
- ('왕릉|^선릉|^정릉|^태릉|^홍릉|^동구릉|능원|능$|고분|고도$|유적|유적지|읍성|산성|토성|주성|남한산성|북한산성|고려궁지|문화유산|서원$|향교$|선비촌|경기전|오죽헌|동궁과월지|대릉원|노서리|쪽샘|첨성대|오목대|월영교|수원화성|행궁$|행궁가|^.+문$|숭례문|흥인지문|독립문|광화문|풍남문|팔달문|장안문|동대문$|남대문$|^.+루$|광한루|촉석루|죽서루|만대루|영남루|^.+사지$|정림사지', 'tomb_historic'),
- ('한옥마을|민속촌|전통마을|민속마을|문화마을|북촌$|서촌$|감천문화마을|양동마을|하회마을|외암마을|왕곡마을|전주한옥|전주한옥마을', 'traditional_village'),
- ('야시장|밤시장', 'night_market'),
- ('수산시장|어시장|자갈치|소래포구|구룡포|주문진|속초중앙시장.*어시장', 'market_seafood'),
- ('시장$|전통시장|광장시장|남대문시장|동대문시장|통인시장|망원시장|국제시장|부평시장|중앙시장|BIFF광장|깡통시장|남포동$', 'market_traditional'),
- ('백화점|면세점|쇼핑몰|몰$|복합쇼핑|스타필드|이마트|코엑스|롯데월드몰|가로수길.*몰|타임스퀘어|디큐브|디큐브시티|롯데몰|현대시티몰', 'department_store'),
- ('아울렛|프리미엄아울렛|시즌아울렛', 'outlet'),
- ('광화문|시청$|청계천|성수동|연남동|이태원|망원동|북촌$|서촌$|을지로$|가로수길|경리단길|샤로수길|망원|연희동|인사동|삼청동|익선동|서순라길|남대문로|홍대|홍익대|건대$|건대거리|신촌$|해방촌|용산공예단지|부산.*해리단길|해리단길|제주.*탑동|탑동광장', 'street_plaza'),
- ('거리$|^.+거리\\s|^.+로$|^.+길$|골목$|광장$|마을$|동네|로데오|단지$|상점가|쇼핑거리|먹자골목|예술의거리|벽화마을', 'street_plaza'),
- ('타워|전망대|뷰포인트|스카이|루프탑|전망$|^N서울|남산서울타워', 'tower_observatory'),
- ('박물관|미술관|뮤지엄|museum|기념관|아트센터|아트홀|문학관|역사관|체험관|과학관|전시관|갤러리|예술관|디자인플라자|DDP|테디베어|티뮤지엄|오설록|스페이스워크|아트밸리|포천아트밸리', 'museum'),
- ('도서관|문화회관|문화원|아트빌리지|예술의전당', 'library_culture_center'),
- ('에버랜드|롯데월드$|레전드$|월드$|테마파크|놀이공원|랜드$|어드벤처|한국민속촌|드림랜드|월미테마파크', 'theme_park'),
- ('아쿠아리움|수족관|아쿠아|씨라이프|동물원|사파리|아쿠아필드', 'aquarium_zoo'),
- ('성당$|교회$|채플|수도원|^명동성당|약현성당|중림동성당', 'religious_site'),
- ('갈비|삼겹살|돼지|소고기|등심|안심|불고기|고기집|숯불|화로구이', 'bbq_restaurant'),
- ('국밥|순대|냉면|국수|면옥|분식|떡볶이|김밥|만두|짜장면|짬뽕', 'noodle_restaurant'),
- ('한정식|한식|삼계탕|곰탕|설렁탕|족발|보쌈|닭갈비|찜닭|토속촌|광장시장.*빈대떡|마약김밥', 'korean_restaurant'),
- ('베이커리|빵집|제과|제빵|베이글', 'bakery'),
- ('카페|커피|coffee|디저트|아이스크림|티하우스|찻집|밀크티', 'cafe'),
- ('패러글라이딩|서핑|스쿠버|스키장|스키리조트|보드|짚라인|루지|카약|요트|보트|승마|승마장|스카이다이빙|번지점프|체험$|온천$|^.+온천|유성온천|수안보온천|온천랜드|찜질방|스파$|녹차탕|해수탕|^.+탕$|율포해수녹차탕', 'leisure_sport'),
- ('리조트|호텔|콘도|풀빌라|펜션|모텔|게스트하우스|^워커힐$|^.+호텔$|^.+리조트$', 'lodging'),
- ('다리$|^.+다리$|^.+교$|엑스포다리|영도대교|광안대교|새천년대교', 'street_plaza'),
- ('차이나타운|이태원로|용산기지|양림동|예술촌|아트빌리지|아트밸리|아트타운|예술마을|예술의거리|벽화마을|창동예술촌', 'street_plaza'),
- ('63빌딩|타워팰리스|롯데월드타워|광화빌딩|^.+빌딩$|광화문빌딩', 'tower_observatory'),
- ('^.+촌$|선비촌|민속촌|국악촌|문학촌|최참판댁|^.+댁$|^.+종가$|^.+고택$|^.+가옥$', 'traditional_village'),
+ (
+ "봉은사|해동용궁사|불국사|석굴암|낙산사|월정사|향일암|선암사|구인사|마곡사|전등사|진관사|용궁사|부석사|보리암|쌍계사|선운사|용문사|해인사|통도사|범어사|송광사|법주사|미황사|화엄사|쌍봉사|운주사|금산사|내장사|관음사|약천사|약사사|봉정사|봉선사|적천사|자장사|봉선사|동학사|갑사|마이산탑사|청룡사|봉선사|관룡사|사불산|불교문화관",
+ "temple",
+ ),
+ (
+ "만장굴|고씨굴|천지연.*동굴|화암동굴|단양고수동굴|고수동굴|환선굴|여천굴|동굴$|관광동굴|대금굴|해저터널|관광터널",
+ "cave",
+ ),
+ ("케이블카|모노레일|곤돌라|로프웨이|루지$|짚라인|집라인|레일바이크", "cable_car"),
+ ("목장|양떼목장|허브농장|농원$|체험농장|승마장", "ranch_farm"),
+ (
+ "산$|^[가-힣]+산\\s|산림욕|봉우리|봉$|폭포|계곡|숲$|호수|호$|강$|바다|해수욕장|해변$|해안|해변로|해돋이|일출|일몰|만$|곶$|섬$|비치$|^.+도$|^오동도|^외도|^청산도|^보길도|^외연도|^안면도|^거문도|^월미도|^남이섬|공원|숲길|올레|둘레길|등산로|언덕|고개|평원|벌판|초원|꽃밭|들꽃|수목원|식물원|지질공원|자연휴양림|휴양림|자연공원|국립공원|도립공원|가든|편백|편백숲|핀크스|메타세콰이어|소쇄원|죽녹원|관방제림|보성녹차밭|녹차밭|식물원|저수지$|^.+호$|의림지|화진포|두물머리|세미원|태화강국가정원|방조림|어부림|^.+림$|불광천|청계천|^.+천$|동촌유원지|유원지$",
+ "nature_outdoor",
+ ),
+ (
+ "낙화암|외돌개|주상절리|정방폭포|천지연|용두암|섭지코지|성산일출봉|비자림|사려니숲|에코랜드|카멜리아힐|선유도|영금정|공지천|경포대|정동진|월정리|함덕|애월|순천만습지|순천만|우포늪|화담숲|아침고요|남이섬|쁘띠프랑스|대왕암|간절곶|호미곶|가천다랭이|용궁리|섭지|올레길|둘레길|태종대|갓바위|신선대|촛대바위|하조대|화진포|정선아우라지|탄금대|통일전망대|묵호항|구룡포항|항구$",
+ "scenic_spot",
+ ),
+ ("경복궁|창덕궁|창경궁|덕수궁|경희궁|운현궁|종묘", "palace"),
+ (
+ "왕릉|^선릉|^정릉|^태릉|^홍릉|^동구릉|능원|능$|고분|고도$|유적|유적지|읍성|산성|토성|주성|남한산성|북한산성|고려궁지|문화유산|서원$|향교$|선비촌|경기전|오죽헌|동궁과월지|대릉원|노서리|쪽샘|첨성대|오목대|월영교|수원화성|행궁$|행궁가|^.+문$|숭례문|흥인지문|독립문|광화문|풍남문|팔달문|장안문|동대문$|남대문$|^.+루$|광한루|촉석루|죽서루|만대루|영남루|^.+사지$|정림사지",
+ "tomb_historic",
+ ),
+ (
+ "한옥마을|민속촌|전통마을|민속마을|문화마을|북촌$|서촌$|감천문화마을|양동마을|하회마을|외암마을|왕곡마을|전주한옥|전주한옥마을",
+ "traditional_village",
+ ),
+ ("야시장|밤시장", "night_market"),
+ ("수산시장|어시장|자갈치|소래포구|구룡포|주문진|속초중앙시장.*어시장", "market_seafood"),
+ (
+ "시장$|전통시장|광장시장|남대문시장|동대문시장|통인시장|망원시장|국제시장|부평시장|중앙시장|BIFF광장|깡통시장|남포동$",
+ "market_traditional",
+ ),
+ (
+ "백화점|면세점|쇼핑몰|몰$|복합쇼핑|스타필드|이마트|코엑스|롯데월드몰|가로수길.*몰|타임스퀘어|디큐브|디큐브시티|롯데몰|현대시티몰",
+ "department_store",
+ ),
+ ("아울렛|프리미엄아울렛|시즌아울렛", "outlet"),
+ (
+ "광화문|시청$|청계천|성수동|연남동|이태원|망원동|북촌$|서촌$|을지로$|가로수길|경리단길|샤로수길|망원|연희동|인사동|삼청동|익선동|서순라길|남대문로|홍대|홍익대|건대$|건대거리|신촌$|해방촌|용산공예단지|부산.*해리단길|해리단길|제주.*탑동|탑동광장",
+ "street_plaza",
+ ),
+ (
+ "거리$|^.+거리\\s|^.+로$|^.+길$|골목$|광장$|마을$|동네|로데오|단지$|상점가|쇼핑거리|먹자골목|예술의거리|벽화마을",
+ "street_plaza",
+ ),
+ ("타워|전망대|뷰포인트|스카이|루프탑|전망$|^N서울|남산서울타워", "tower_observatory"),
+ (
+ "박물관|미술관|뮤지엄|museum|기념관|아트센터|아트홀|문학관|역사관|체험관|과학관|전시관|갤러리|예술관|디자인플라자|DDP|테디베어|티뮤지엄|오설록|스페이스워크|아트밸리|포천아트밸리",
+ "museum",
+ ),
+ ("도서관|문화회관|문화원|아트빌리지|예술의전당", "library_culture_center"),
+ (
+ "에버랜드|롯데월드$|레전드$|월드$|테마파크|놀이공원|랜드$|어드벤처|한국민속촌|드림랜드|월미테마파크",
+ "theme_park",
+ ),
+ ("아쿠아리움|수족관|아쿠아|씨라이프|동물원|사파리|아쿠아필드", "aquarium_zoo"),
+ ("성당$|교회$|채플|수도원|^명동성당|약현성당|중림동성당", "religious_site"),
+ ("갈비|삼겹살|돼지|소고기|등심|안심|불고기|고기집|숯불|화로구이", "bbq_restaurant"),
+ ("국밥|순대|냉면|국수|면옥|분식|떡볶이|김밥|만두|짜장면|짬뽕", "noodle_restaurant"),
+ (
+ "한정식|한식|삼계탕|곰탕|설렁탕|족발|보쌈|닭갈비|찜닭|토속촌|광장시장.*빈대떡|마약김밥",
+ "korean_restaurant",
+ ),
+ ("베이커리|빵집|제과|제빵|베이글", "bakery"),
+ ("카페|커피|coffee|디저트|아이스크림|티하우스|찻집|밀크티", "cafe"),
+ (
+ "패러글라이딩|서핑|스쿠버|스키장|스키리조트|보드|짚라인|루지|카약|요트|보트|승마|승마장|스카이다이빙|번지점프|체험$|온천$|^.+온천|유성온천|수안보온천|온천랜드|찜질방|스파$|녹차탕|해수탕|^.+탕$|율포해수녹차탕",
+ "leisure_sport",
+ ),
+ ("리조트|호텔|콘도|풀빌라|펜션|모텔|게스트하우스|^워커힐$|^.+호텔$|^.+리조트$", "lodging"),
+ ("다리$|^.+다리$|^.+교$|엑스포다리|영도대교|광안대교|새천년대교", "street_plaza"),
+ (
+ "차이나타운|이태원로|용산기지|양림동|예술촌|아트빌리지|아트밸리|아트타운|예술마을|예술의거리|벽화마을|창동예술촌",
+ "street_plaza",
+ ),
+ ("63빌딩|타워팰리스|롯데월드타워|광화빌딩|^.+빌딩$|광화문빌딩", "tower_observatory"),
+ (
+ "^.+촌$|선비촌|민속촌|국악촌|문학촌|최참판댁|^.+댁$|^.+종가$|^.+고택$|^.+가옥$",
+ "traditional_village",
+ ),
]
@@ -254,12 +364,12 @@ def resolve_hours(name: str, hint: str | None = None) -> HoursSpec:
h = (hint or "").strip()
fallback = {
- "식당": "general_restaurant",
- "카페": "cafe",
+ "식당": "general_restaurant",
+ "카페": "cafe",
"문화시설": "museum",
- "쇼핑": "department_store",
- "레포츠": "leisure_sport",
- "축제": "default_attraction",
+ "쇼핑": "department_store",
+ "레포츠": "leisure_sport",
+ "축제": "default_attraction",
}.get(h, "default_attraction")
return SUB_CATEGORIES[fallback]
diff --git a/src/data/kakao_local.py b/src/data/kakao_local.py
index 389200e..a252ed2 100644
--- a/src/data/kakao_local.py
+++ b/src/data/kakao_local.py
@@ -9,13 +9,12 @@
- 키는 환경변수로만 관리한다.
- 모듈 간 데이터는 Pydantic 모델(KakaoPlace)로 주고받는다.
"""
-from __future__ import annotations
-import os
+from __future__ import annotations
import httpx
-from src.data.models import KakaoPlace
+from src.data.models import KakaoPlace, Settings
_KEYWORD_URL = "https://dapi.kakao.com/v2/local/search/keyword.json"
_ADDRESS_URL = "https://dapi.kakao.com/v2/local/search/address.json"
@@ -33,8 +32,10 @@ def __init__(self, api_key: str | None = None, timeout_sec: float = 3.0) -> None
self.stats: dict[str, int] = {"hit": 0, "miss": 0, "api_ok": 0, "api_fail": 0}
@classmethod
- def from_env(cls) -> KakaoLocalClient:
- return cls(api_key=os.environ.get("KAKAO_REST_API_KEY", ""))
+ def from_settings(cls, settings: Settings | None = None) -> KakaoLocalClient:
+ return cls(api_key=(settings or Settings()).kakao_rest_api_key)
+
+ from_env = from_settings
@property
def enabled(self) -> bool:
diff --git a/src/data/models.py b/src/data/models.py
index 7e7eac6..64ba8d4 100644
--- a/src/data/models.py
+++ b/src/data/models.py
@@ -4,14 +4,39 @@
Pydantic v2 can resolve forward references (e.g. ExplanationItem,
DayRouteComparison) that are defined later in this file.
"""
+
from __future__ import annotations
import hashlib
import re
+from datetime import date as date_type
+from pathlib import Path
from typing import Literal
from pydantic import BaseModel, Field, computed_field, field_validator, model_validator
-from pydantic_settings import BaseSettings
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+def _validate_hhmm(value: str, field_name: str = "time") -> str:
+ if not re.fullmatch(r"\d{2}:\d{2}", value):
+ raise ValueError(f"{field_name} must be HH:MM format, got: {value!r}")
+ hour, minute = int(value[:2]), int(value[3:])
+ if not (0 <= hour <= 23 and 0 <= minute <= 59):
+ raise ValueError(f"Invalid {field_name} value: {value!r}")
+ return value
+
+
+def _validate_iso_date(value: str) -> str:
+ try:
+ parsed = date_type.fromisoformat(value)
+ except ValueError as exc:
+ raise ValueError("date must be an ISO date in YYYY-MM-DD format") from exc
+ if parsed.isoformat() != value:
+ raise ValueError("date must be an ISO date in YYYY-MM-DD format")
+ return value
+
+
+_PROJECT_ROOT = Path(__file__).resolve().parents[2]
# ---------------------------------------------------------------------------
@@ -32,7 +57,7 @@ class KakaoPlace(BaseModel):
class PlaceEvidence(BaseModel):
- """지식그래프(Neo4j)에서 검색된 장소 근거 1건 (Region 컨텍스트 포함)."""
+ """로컬 장소 근거 검색 결과 1건 (Region 컨텍스트 포함)."""
place_id: str
name: str
@@ -86,7 +111,7 @@ class Scores(BaseModel):
area_intensity: float
@model_validator(mode="after")
- def validate_ranges(self) -> "Scores":
+ def validate_ranges(self) -> Scores:
for fname in ("efficiency", "feasibility", "purpose_fit", "flow", "area_intensity"):
v = getattr(self, fname)
if not 0.0 <= v <= 1.0:
@@ -108,7 +133,7 @@ class POI(BaseModel):
lat: float
lng: float
open_start: str # HH:MM
- open_end: str # HH:MM
+ open_end: str # HH:MM
duration_min: int
category: str = ""
# 영업시간이 실측/검증값이 아니라 카테고리 추정값이면 True.
@@ -157,8 +182,8 @@ def validate_duration(cls, v: int) -> int:
class PlaceInput(BaseModel):
name: str
- visit_order: int | None = None # None → DayPlan에서 해당 일자 내 리스트 순서 자동 할당
- is_accommodation: bool = False # True → 숙소(Depot). M3/M4 백트래킹 계산 시 기준점 역할
+ visit_order: int | None = None # None → DayPlan에서 해당 일자 내 리스트 순서 자동 할당
+ is_accommodation: bool = False # True → 숙소(Depot). M3/M4 백트래킹 계산 시 기준점 역할
@field_validator("visit_order")
@classmethod
@@ -172,6 +197,7 @@ def validate_order(cls, v: int | None) -> int | None:
class DayPlan(BaseModel):
"""하루 일정 — 장소 이름과 방문 순서 입력."""
+
places: list[PlaceInput]
@field_validator("places")
@@ -184,7 +210,7 @@ def validate_place_count(cls, v: list[PlaceInput]) -> list[PlaceInput]:
return v
@model_validator(mode="after")
- def auto_fill_visit_order(self) -> "DayPlan":
+ def auto_fill_visit_order(self) -> DayPlan:
"""visit_order 미입력 시 해당 일자 내 리스트 위치(1-based)로 자동 할당."""
for i, place in enumerate(self.places):
if place.visit_order is None:
@@ -193,11 +219,22 @@ def auto_fill_visit_order(self) -> "DayPlan":
class ItineraryPlan(BaseModel):
- days: list[DayPlan] # 일자별 장소 목록 (len = travel_days)
- party_size: Literal[1, 2, 3, 4, 5] # 여행 인원 (5 = 5인 이상)
+ days: list[DayPlan] # 일자별 장소 목록 (len = travel_days)
+ party_size: Literal[1, 2, 3, 4, 5] # 여행 인원 (5 = 5인 이상)
party_type: Literal["혼자", "친구", "연인", "가족", "아기동반", "어르신동반"]
travel_type: Literal["cultural", "nature", "shopping", "food", "adventure"] | None = None
date: str # 여행 시작일 (YYYY-MM-DD)
+ start_time: str = "09:00"
+
+ @field_validator("date")
+ @classmethod
+ def validate_date(cls, v: str) -> str:
+ return _validate_iso_date(v)
+
+ @field_validator("start_time")
+ @classmethod
+ def validate_start_time(cls, v: str) -> str:
+ return _validate_hhmm(v, "start_time")
@field_validator("days")
@classmethod
@@ -247,26 +284,30 @@ def validate_score_range(cls, v: int) -> int:
return v
@model_validator(mode="after")
- def hard_fail_score_cap(self) -> "ValidationResult":
+ def hard_fail_score_cap(self) -> ValidationResult:
if self.hard_fails and self.final_score >= 60:
raise ValueError("final_score must be <= 59 when hard_fails are present")
return self
class Settings(BaseSettings):
+ environment: str = "development"
+ api_auth_token: str = ""
+ cors_allowed_origins: str = "http://localhost:8000,http://127.0.0.1:8000"
anthropic_api_key: str = ""
claude_model: str = "claude-haiku-4-5"
tour_api_key: str = ""
kakao_rest_api_key: str = ""
kakao_mobility_key: str = ""
seoul_data_api_key: str = ""
+ naver_api_key: str = ""
wellness_api_key: str = ""
barrier_free_api_key: str = ""
- model_config = {"env_file": ".env", "extra": "ignore"}
+ model_config = SettingsConfigDict(env_file=_PROJECT_ROOT / ".env", extra="ignore")
@model_validator(mode="after")
- def fill_gov_api_keys(self) -> "Settings":
+ def fill_gov_api_keys(self) -> Settings:
"""wellness_api_key / barrier_free_api_key 미설정 시 tour_api_key로 대체."""
if not self.wellness_api_key:
self.wellness_api_key = self.tour_api_key
@@ -284,7 +325,7 @@ class VRPTWPlace(BaseModel):
name: str
lng: float
lat: float
- open: str # HH:MM
+ open: str # HH:MM
close: str # HH:MM
stay_duration: int # minutes; 0 allowed for depot
is_depot: bool = False
@@ -292,12 +333,7 @@ class VRPTWPlace(BaseModel):
@field_validator("open", "close")
@classmethod
def validate_hhmm(cls, v: str) -> str:
- if not re.fullmatch(r"\d{2}:\d{2}", v):
- raise ValueError(f"Time must be HH:MM format, got: {v!r}")
- h, m = int(v[:2]), int(v[3:])
- if not (0 <= h <= 23 and 0 <= m <= 59):
- raise ValueError(f"Invalid time value: {v!r}")
- return v
+ return _validate_hhmm(v)
@field_validator("lat")
@classmethod
@@ -344,6 +380,12 @@ def at_least_one(cls, v: list[VRPTWPlace]) -> list[VRPTWPlace]:
class VRPTWRequest(BaseModel):
days: list[VRPTWDay]
+ start_time: str = "09:00"
+
+ @field_validator("start_time")
+ @classmethod
+ def validate_start_time(cls, v: str) -> str:
+ return _validate_hhmm(v, "start_time")
@field_validator("days")
@classmethod
@@ -362,6 +404,7 @@ class DeepDiveItem(BaseModel):
class ExplanationItem(BaseModel):
"""ExplainEngine이 생성하는 4단계 설명 항목."""
+
item_type: Literal["hard_fail", "warning", "penalty", "bonus", "overall"]
item_key: str
fact: str
@@ -373,18 +416,18 @@ class ExplanationItem(BaseModel):
class DayRouteComparison(BaseModel):
day_index: int
- user_order: list[str] # place names in user order
+ user_order: list[str] # place names in user order
optimal_order: list[str] | None # None when ortools unavailable
user_travel_seconds: int
optimal_travel_seconds: int | None
class VRPTWResult(BaseModel):
- risk_score: int # 0–100
- passed: bool # risk_score >= 60
+ risk_score: int # 0–100
+ passed: bool # risk_score >= 60
user_total_travel_seconds: int
optimal_total_travel_seconds: int | None
- efficiency_gap: float | None # (user - optimal) / optimal
+ efficiency_gap: float | None # (user - optimal) / optimal
optimal_route: list[DayRouteComparison] | None
deep_dive: list[DeepDiveItem]
summary: str
diff --git a/src/data/party_config.py b/src/data/party_config.py
index b7d5aef..ea527b5 100644
--- a/src/data/party_config.py
+++ b/src/data/party_config.py
@@ -10,6 +10,7 @@
가족 : 10h (어린 자녀 동반 가능성)
아기동반 / 어르신동반: 8h (취약 그룹 동반, 조기 경고)
"""
+
from __future__ import annotations
from dataclasses import dataclass
@@ -17,16 +18,16 @@
@dataclass(frozen=True)
class PartyProfile:
- speed_factor: float # 체력 부담 임계 보정 계수 (1.0 = 기준)
- fatigue_hours: int # 일정 과밀 경고 기준 시간
+ speed_factor: float # 체력 부담 임계 보정 계수 (1.0 = 기준)
+ fatigue_hours: int # 일정 과밀 경고 기준 시간
PARTY_PROFILES: dict[str, PartyProfile] = {
- "혼자": PartyProfile(speed_factor=1.0, fatigue_hours=12),
- "친구": PartyProfile(speed_factor=1.0, fatigue_hours=12),
- "연인": PartyProfile(speed_factor=1.0, fatigue_hours=12),
- "가족": PartyProfile(speed_factor=0.9, fatigue_hours=10),
- "아기동반": PartyProfile(speed_factor=0.8, fatigue_hours=8),
+ "혼자": PartyProfile(speed_factor=1.0, fatigue_hours=12),
+ "친구": PartyProfile(speed_factor=1.0, fatigue_hours=12),
+ "연인": PartyProfile(speed_factor=1.0, fatigue_hours=12),
+ "가족": PartyProfile(speed_factor=0.9, fatigue_hours=10),
+ "아기동반": PartyProfile(speed_factor=0.8, fatigue_hours=8),
"어르신동반": PartyProfile(speed_factor=0.8, fatigue_hours=8),
}
diff --git a/src/data/region_config.py b/src/data/region_config.py
index 6c54596..06b1d3b 100644
--- a/src/data/region_config.py
+++ b/src/data/region_config.py
@@ -8,6 +8,7 @@
MEDIUM — 지방 광역시, 수도권 외곽 (100–299 POI/km²)
LOW — 농어촌·산간·도서 지역 (<100 POI/km²)
"""
+
from __future__ import annotations
from dataclasses import dataclass
@@ -16,21 +17,22 @@
@dataclass(frozen=True)
class RegionThresholds:
"""지역 티어별 VRPTW/Scoring 임계값."""
- tier: str # "high" | "medium" | "low"
+
+ tier: str # "high" | "medium" | "low"
# ── ClusterDispersion ────────────────────────────────────────────
- dist_warn_km: float # M2 경고 임계 직선거리
+ dist_warn_km: float # M2 경고 임계 직선거리
dist_risk_km: float
dist_crit_km: float
- switch_warn: int # M1 시군구 전환 경고 횟수
+ switch_warn: int # M1 시군구 전환 경고 횟수
switch_crit: int
# ── HardFail / Warning ───────────────────────────────────────────
- physical_strain_km: float # 1일 총 이동거리 경고 임계
- dense_schedule_min: int # 일정 과밀 임계 (분)
+ physical_strain_km: float # 1일 총 이동거리 경고 임계
+ dense_schedule_min: int # 일정 과밀 임계 (분)
# ── Scoring ──────────────────────────────────────────────────────
- fatigue_hours_limit: int # 피로 패널티 기준 시간
+ fatigue_hours_limit: int # 피로 패널티 기준 시간
TIER_HIGH_DENSITY = RegionThresholds(
@@ -70,25 +72,89 @@ class RegionThresholds:
)
# 서울 핵심 25개 자치구 + 경기 핵심 시
-_HIGH_DENSITY_CODES: frozenset[str] = frozenset({
- "11110", "11140", "11170", "11200", "11215", "11230", "11260",
- "11290", "11305", "11320", "11350", "11380", "11410", "11440",
- "11470", "11500", "11530", "11545", "11560", "11590", "11620",
- "11650", "11680", "11710", "11740", # 서울 25구
- "26110", "26140", "26170", "26200", "26230", "26260", "26290",
- "26320", "26350", "26380", "26410", "26440", "26470", "26500",
- "26530", # 부산 15개 구
- "41131", "41133", "41135", "41171", "41173", # 수원·성남·고양
-})
-
-_MEDIUM_DENSITY_CODES: frozenset[str] = frozenset({
- "27110", "27140", "27170", "27200", "27230", "27260", "27290", # 대구
- "28110", "28140", "28170", "28200", "28237", "28245", "28260", # 인천
- "29110", "29140", "29155", "29170", "29200", # 광주
- "30110", "30140", "30170", "30200", "30230", # 대전
- "31110", "31140", "31170", "31200", # 울산
- "36110", # 세종
-})
+_HIGH_DENSITY_CODES: frozenset[str] = frozenset(
+ {
+ "11110",
+ "11140",
+ "11170",
+ "11200",
+ "11215",
+ "11230",
+ "11260",
+ "11290",
+ "11305",
+ "11320",
+ "11350",
+ "11380",
+ "11410",
+ "11440",
+ "11470",
+ "11500",
+ "11530",
+ "11545",
+ "11560",
+ "11590",
+ "11620",
+ "11650",
+ "11680",
+ "11710",
+ "11740", # 서울 25구
+ "26110",
+ "26140",
+ "26170",
+ "26200",
+ "26230",
+ "26260",
+ "26290",
+ "26320",
+ "26350",
+ "26380",
+ "26410",
+ "26440",
+ "26470",
+ "26500",
+ "26530", # 부산 15개 구
+ "41131",
+ "41133",
+ "41135",
+ "41171",
+ "41173", # 수원·성남·고양
+ }
+)
+
+_MEDIUM_DENSITY_CODES: frozenset[str] = frozenset(
+ {
+ "27110",
+ "27140",
+ "27170",
+ "27200",
+ "27230",
+ "27260",
+ "27290", # 대구
+ "28110",
+ "28140",
+ "28170",
+ "28200",
+ "28237",
+ "28245",
+ "28260", # 인천
+ "29110",
+ "29140",
+ "29155",
+ "29170",
+ "29200", # 광주
+ "30110",
+ "30140",
+ "30170",
+ "30200",
+ "30230", # 대전
+ "31110",
+ "31140",
+ "31170",
+ "31200", # 울산
+ "36110", # 세종
+ }
+)
def get_thresholds(sigungu_code: str | None) -> RegionThresholds:
diff --git a/src/data/restaurant_catalog.py b/src/data/restaurant_catalog.py
index 91898d1..3c05a27 100644
--- a/src/data/restaurant_catalog.py
+++ b/src/data/restaurant_catalog.py
@@ -6,6 +6,7 @@
CLAUDE.md 규칙:
- 모듈 간 데이터는 Pydantic 모델(AlternativePOI)로만 주고받는다.
"""
+
from __future__ import annotations
import csv
@@ -14,6 +15,8 @@
from src.data.models import AlternativePOI
from src.utils.geo import haversine_km
+_PROJECT_ROOT = Path(__file__).resolve().parents[2]
+
_RESTAURANT_CODE = "FD"
@@ -48,7 +51,7 @@ def from_csv(cls, path: Path) -> RestaurantCatalog:
@classmethod
def from_default(cls) -> RestaurantCatalog:
- return cls.from_csv(Path("data/jeju_places.csv"))
+ return cls.from_csv(_PROJECT_ROOT / "data" / "jeju_places.csv")
def nearby(
self,
@@ -69,6 +72,12 @@ def nearby(
candidates.append((dist, r))
candidates.sort(key=lambda c: c[0])
return [
- AlternativePOI(name=r["name"], distance_km=round(dist, 2), category="39", lat=r["lat"], lng=r["lng"])
+ AlternativePOI(
+ name=r["name"],
+ distance_km=round(dist, 2),
+ category="39",
+ lat=r["lat"],
+ lng=r["lng"],
+ )
for dist, r in candidates[:limit]
]
diff --git a/src/data/seoul_citydata_client.py b/src/data/seoul_citydata_client.py
index d3ebe2e..88975db 100644
--- a/src/data/seoul_citydata_client.py
+++ b/src/data/seoul_citydata_client.py
@@ -9,11 +9,11 @@
지원 혼잡도 레벨:
여유 → 0.1 | 보통 → 0.4 | 약간 붐빔 → 0.7 | 붐빔 → 1.0
"""
+
from __future__ import annotations
from dataclasses import dataclass, field
from datetime import datetime
-from typing import Optional
import httpx
@@ -22,15 +22,37 @@
# 서울 도시데이터 API 등록 장소명 (115개소 중 주요 관광지)
# 정확한 문자열 일치가 필요 — 오타 시 404 반환
KNOWN_AREAS: set[str] = {
- "경복궁", "창덕궁", "창경궁", "덕수궁", "경희궁",
- "인사동", "북촌한옥마을", "서촌", "남산공원",
- "명동 관광특구", "동대문 관광특구", "이태원 관광특구",
- "강남 MICE 관광특구", "홍대 관광특구",
- "여의도한강공원", "반포한강공원", "뚝섬한강공원",
- "잠실한강공원", "망원한강공원", "이촌한강공원",
- "롯데월드", "코엑스", "국립중앙박물관",
- "서울숲", "올림픽공원", "북한산", "관악산",
- "강남역", "신촌·이대", "건대입구역", "왕십리역",
+ "경복궁",
+ "창덕궁",
+ "창경궁",
+ "덕수궁",
+ "경희궁",
+ "인사동",
+ "북촌한옥마을",
+ "서촌",
+ "남산공원",
+ "명동 관광특구",
+ "동대문 관광특구",
+ "이태원 관광특구",
+ "강남 MICE 관광특구",
+ "홍대 관광특구",
+ "여의도한강공원",
+ "반포한강공원",
+ "뚝섬한강공원",
+ "잠실한강공원",
+ "망원한강공원",
+ "이촌한강공원",
+ "롯데월드",
+ "코엑스",
+ "국립중앙박물관",
+ "서울숲",
+ "올림픽공원",
+ "북한산",
+ "관악산",
+ "강남역",
+ "신촌·이대",
+ "건대입구역",
+ "왕십리역",
}
# 사용자 입력 → API 장소명 별칭 매핑
@@ -60,9 +82,9 @@
@dataclass(frozen=True)
class ForecastSlot:
- time: str # "YYYY-MM-DD HH:MM"
- level: str # "여유" | "보통" | "약간 붐빔" | "붐빔"
- score: float # 0.0~1.0
+ time: str # "YYYY-MM-DD HH:MM"
+ level: str # "여유" | "보통" | "약간 붐빔" | "붐빔"
+ score: float # 0.0~1.0
ppltn_min: int
ppltn_max: int
@@ -71,13 +93,13 @@ class ForecastSlot:
class SeoulRealtimeCongestion:
area_name: str
area_code: str
- level: str # 현재 혼잡도 텍스트
- score: float # 0.0~1.0
+ level: str # 현재 혼잡도 텍스트
+ score: float # 0.0~1.0
ppltn_min: int
ppltn_max: int
- measured_at: str # "YYYY-MM-DD HH:MM"
+ measured_at: str # "YYYY-MM-DD HH:MM"
forecast: list[ForecastSlot] = field(default_factory=list)
- is_replaced: bool = False # REPLACE_YN == 'Y' 이면 추정치
+ is_replaced: bool = False # REPLACE_YN == 'Y' 이면 추정치
class SeoulCityDataClient:
@@ -93,6 +115,7 @@ def __init__(self, api_key: str | None = None, timeout: float = 10.0) -> None:
self._key = api_key
else:
from src.data.models import Settings
+
self._key = Settings().seoul_data_api_key
if not self._key:
raise ValueError("SEOUL_DATA_API_KEY가 설정되지 않았습니다.")
diff --git a/src/data/theme_taxonomy.py b/src/data/theme_taxonomy.py
index 2a7fd65..7575212 100644
--- a/src/data/theme_taxonomy.py
+++ b/src/data/theme_taxonomy.py
@@ -8,11 +8,10 @@
사용자 입력 모델은 UserPreferences로 묶어서 양 축 다중 선택을 허용.
"""
+
from __future__ import annotations
from dataclasses import dataclass, field
-from typing import Literal
-
# ── 축 A: 장소 유형 (List 1) ──────────────────────────────────────────
PLACE_TYPES: list[str] = [
@@ -45,15 +44,15 @@
# 한 PLACE_TYPE에 여러 코드가 매핑될 수 있음 (OR 조건).
# 매핑은 코드의 prefix 매칭 (예: "NA04" → 산 → 모든 NA04로 시작하는 코드)
PLACE_TYPE_TO_LCLS: dict[str, list[str]] = {
- "산": ["NA04", "NA01"], # 산, 국립공원
- "바다": ["NA12", "NA11", "NA13", "NA14"], # 해수욕장, 해안절경, 섬, 항구
+ "산": ["NA04", "NA01"], # 산, 국립공원
+ "바다": ["NA12", "NA11", "NA13", "NA14"], # 해수욕장, 해안절경, 섬, 항구
"실내 여행지": ["VE01", "VE03", "VE04", "VE05"], # 박물관, 전시관, 미술관, 체험관
- "액티비티": ["EX"], # 레포츠 전체
- "문화_역사": ["VE01", "VE02", "HS"], # 박물관, 기념관, 역사관광지
- "테마파크": ["EX21"], # 테마파크 (레포츠 하위)
- "카페": ["FD02"], # 카페·전통찻집
- "전통시장": ["SH01"], # 5일·전통시장
- "축제": [], # contentTypeId=15로 별도 매칭
+ "액티비티": ["EX"], # 레포츠 전체
+ "문화_역사": ["VE01", "VE02", "HS"], # 박물관, 기념관, 역사관광지
+ "테마파크": ["EX21"], # 테마파크 (레포츠 하위)
+ "카페": ["FD02"], # 카페·전통찻집
+ "전통시장": ["SH01"], # 5일·전통시장
+ "축제": [], # contentTypeId=15로 별도 매칭
}
@@ -66,15 +65,15 @@
# ── TRAVEL_STYLE 메타 정보 (LLM 프롬프트 컨텍스트용) ─────────────────
# 각 스타일에 대한 한 줄 설명 — Claude API 호출 시 system 또는 user 프롬프트에 포함
TRAVEL_STYLE_DESCRIPTIONS: dict[str, str] = {
- "체험_액티비티": "직접 몸으로 부딪히는 체험형 활동 (서핑, 등산, ATV 등)",
- "SNS 핫플레이스": "사진 찍기 좋고 트렌디한 곳 (인스타 감성 카페, 포토존)",
- "자연과 함께": "자연 풍경 중심 (산, 바다, 숲, 공원)",
+ "체험_액티비티": "직접 몸으로 부딪히는 체험형 활동 (서핑, 등산, ATV 등)",
+ "SNS 핫플레이스": "사진 찍기 좋고 트렌디한 곳 (인스타 감성 카페, 포토존)",
+ "자연과 함께": "자연 풍경 중심 (산, 바다, 숲, 공원)",
"유명 관광지는 필수": "랜드마크·필수 코스 (경복궁, 해운대 등)",
- "여유롭게 힐링": "조용하고 편안한 휴식 (한적한 카페, 명상, 온천)",
- "문화_예술_역사": "박물관·미술관·고궁·전통 문화 체험",
- "여행지 느낌 물씬": "그 지역 고유의 분위기·전통 강하게 살아있는 곳",
- "쇼핑은 열정적으로": "쇼핑 위주 (백화점, 면세점, 시장, 쇼핑몰)",
- "관광보다 먹방": "유명 맛집·식도락 위주 (현지 음식, 노포)",
+ "여유롭게 힐링": "조용하고 편안한 휴식 (한적한 카페, 명상, 온천)",
+ "문화_예술_역사": "박물관·미술관·고궁·전통 문화 체험",
+ "여행지 느낌 물씬": "그 지역 고유의 분위기·전통 강하게 살아있는 곳",
+ "쇼핑은 열정적으로": "쇼핑 위주 (백화점, 면세점, 시장, 쇼핑몰)",
+ "관광보다 먹방": "유명 맛집·식도락 위주 (현지 음식, 노포)",
}
@@ -82,6 +81,7 @@
@dataclass
class UserPreferences:
"""사용자가 선택한 테마. 두 축 모두 다중 선택 허용 (각 1개 이상)."""
+
place_types: list[str] = field(default_factory=list)
travel_styles: list[str] = field(default_factory=list)
@@ -89,16 +89,10 @@ def __post_init__(self) -> None:
# 검증: 모든 항목이 정의된 테마인지 확인
invalid_pt = [p for p in self.place_types if p not in PLACE_TYPES]
if invalid_pt:
- raise ValueError(
- f"정의되지 않은 PLACE_TYPE: {invalid_pt}. "
- f"허용: {PLACE_TYPES}"
- )
+ raise ValueError(f"정의되지 않은 PLACE_TYPE: {invalid_pt}. 허용: {PLACE_TYPES}")
invalid_ts = [s for s in self.travel_styles if s not in TRAVEL_STYLES]
if invalid_ts:
- raise ValueError(
- f"정의되지 않은 TRAVEL_STYLE: {invalid_ts}. "
- f"허용: {TRAVEL_STYLES}"
- )
+ raise ValueError(f"정의되지 않은 TRAVEL_STYLE: {invalid_ts}. 허용: {TRAVEL_STYLES}")
if not self.place_types and not self.travel_styles:
raise ValueError("최소 하나의 PLACE_TYPE 또는 TRAVEL_STYLE을 선택해야 합니다.")
diff --git a/src/data/tour_api.py b/src/data/tour_api.py
index 295454b..9c7328c 100644
--- a/src/data/tour_api.py
+++ b/src/data/tour_api.py
@@ -1,4 +1,5 @@
"""한국관광공사 TourAPI v2 비동기 클라이언트 (httpx + Graceful Fallback)."""
+
from __future__ import annotations
import re
@@ -59,7 +60,7 @@ def __init__(
self._hours_cache: dict[str, tuple[str, str]] = {}
@classmethod
- def from_settings(cls, settings: Settings | None = None) -> "TourAPIClient | None":
+ def from_settings(cls, settings: Settings | None = None) -> TourAPIClient | None:
"""Settings에서 키 로드. 키 없으면 None 반환 (Graceful Fallback 진입점)."""
if settings is None:
settings = Settings()
@@ -76,13 +77,13 @@ async def search_poi(
"""키워드로 POI 검색. 실패 시 빈 리스트 반환."""
params: dict[str, Any] = {
"serviceKey": self._key,
- "numOfRows": num_of_rows,
- "pageNo": 1,
- "MobileOS": "ETC",
- "MobileApp": self._mobile_app,
- "arrange": "A",
- "keyword": keyword,
- "_type": "json",
+ "numOfRows": num_of_rows,
+ "pageNo": 1,
+ "MobileOS": "ETC",
+ "MobileApp": self._mobile_app,
+ "arrange": "A",
+ "keyword": keyword,
+ "_type": "json",
}
if content_type_id is not None:
params["contentTypeId"] = content_type_id
@@ -106,16 +107,18 @@ async def search_poi(
if not lat or not lng:
continue
open_s, close_s = await self.get_operating_hours(content_id, ctype)
- pois.append(POI(
- poi_id=content_id,
- name=str(item.get("title", keyword)),
- lat=lat,
- lng=lng,
- open_start=open_s,
- open_end=close_s,
- duration_min=60,
- category=str(ctype),
- ))
+ pois.append(
+ POI(
+ poi_id=content_id,
+ name=str(item.get("title", keyword)),
+ lat=lat,
+ lng=lng,
+ open_start=open_s,
+ open_end=close_s,
+ duration_min=60,
+ category=str(ctype),
+ )
+ )
except Exception:
continue
return pois
@@ -130,12 +133,12 @@ async def get_operating_hours(
return self._hours_cache[content_id]
params: dict[str, Any] = {
- "serviceKey": self._key,
- "contentId": content_id,
+ "serviceKey": self._key,
+ "contentId": content_id,
"contentTypeId": content_type_id,
- "MobileOS": "ETC",
- "MobileApp": self._mobile_app,
- "_type": "json",
+ "MobileOS": "ETC",
+ "MobileApp": self._mobile_app,
+ "_type": "json",
}
result = (_FALLBACK_OPEN, _FALLBACK_CLOSE)
diff --git a/src/data/wellness_api.py b/src/data/wellness_api.py
index db85188..bbdf556 100644
--- a/src/data/wellness_api.py
+++ b/src/data/wellness_api.py
@@ -1,4 +1,5 @@
"""한국관광공사 웰니스 관광 정보 API 클라이언트 (B551011/WellnessTursmService)."""
+
from __future__ import annotations
from dataclasses import dataclass
@@ -17,8 +18,8 @@ class WellnessPlace:
content_id: str
title: str
addr: str
- lat: float # mapY
- lng: float # mapX
+ lat: float # mapY
+ lng: float # mapX
cat1: str = ""
cat2: str = ""
cat3: str = ""
@@ -55,7 +56,7 @@ def __init__(self, api_key: str, timeout_sec: float = 10.0) -> None:
self._timeout = timeout_sec
@classmethod
- def from_settings(cls, settings: Settings | None = None) -> "WellnessAPIClient | None":
+ def from_settings(cls, settings: Settings | None = None) -> WellnessAPIClient | None:
if settings is None:
settings = Settings()
key = settings.wellness_api_key
@@ -98,20 +99,22 @@ async def fetch_page(
addr = str(item.get("baseAddr") or item.get("addr1") or item.get("addr") or "")
lat = _safe_float(item.get("mapY") or item.get("mapy") or item.get("lat"))
lng = _safe_float(item.get("mapX") or item.get("mapx") or item.get("lng"))
-
+
if not content_id or lat == 0.0 or lng == 0.0:
continue
-
- places.append(WellnessPlace(
- content_id=content_id,
- title=title,
- addr=addr,
- lat=lat,
- lng=lng,
- cat1=str(item.get("cat1", "")),
- cat2=str(item.get("cat2", "")),
- cat3=str(item.get("cat3", "")),
- ))
+
+ places.append(
+ WellnessPlace(
+ content_id=content_id,
+ title=title,
+ addr=addr,
+ lat=lat,
+ lng=lng,
+ cat1=str(item.get("cat1", "")),
+ cat2=str(item.get("cat2", "")),
+ cat3=str(item.get("cat3", "")),
+ )
+ )
return places
async def fetch_all(self, num_of_rows: int = 100) -> list[WellnessPlace]:
diff --git a/src/explain/explain_engine.py b/src/explain/explain_engine.py
index 8fe248e..c577d32 100644
--- a/src/explain/explain_engine.py
+++ b/src/explain/explain_engine.py
@@ -10,26 +10,28 @@
- Graceful fallback: API 키 없거나 호출 실패 시 규칙 기반 설명으로 대체
- 이슈 없을 때 LLM 미호출: 불필요한 API 호출 방지
"""
+
from __future__ import annotations
import hashlib
import json
-import os
from collections import OrderedDict
from typing import Any
-from src.data.graph_retriever import GraphRetriever
+from src.data.evidence_retriever import LocalEvidenceRetriever
from src.data.models import (
AlternativePOI,
ExplanationItem,
HardFail,
ItineraryPlan,
Scores,
+ Settings,
Warning,
)
try:
import anthropic
+
_ANTHROPIC_AVAILABLE = True
except ImportError:
_ANTHROPIC_AVAILABLE = False
@@ -41,6 +43,7 @@
# ── 메모리 캐시 (모듈 단위, 콘텐츠 해시 키) ──────────────────────────────
+
class _LRUCache:
"""최대 크기 제한 LRU 캐시 — collections.OrderedDict 기반 (외부 의존성 없음)."""
@@ -175,8 +178,15 @@ def _cache_key(
final_score: int,
) -> str:
payload = {
- "hf": sorted([(h.fail_type, h.poi_name or "", h.day_index if h.day_index is not None else -1) for h in hard_fails]),
- "w": sorted([(w.warning_type, w.day_index if w.day_index is not None else -1) for w in warnings]),
+ "hf": sorted(
+ [
+ (h.fail_type, h.poi_name or "", h.day_index if h.day_index is not None else -1)
+ for h in hard_fails
+ ]
+ ),
+ "w": sorted(
+ [(w.warning_type, w.day_index if w.day_index is not None else -1) for w in warnings]
+ ),
"p": sorted(penalty_breakdown.items()),
"score": final_score,
}
@@ -184,7 +194,7 @@ def _cache_key(
return hashlib.md5(raw.encode("utf-8")).hexdigest()
-def _graph_context(poi_name: str, graph: GraphRetriever | None) -> dict | None:
+def _graph_context(poi_name: str, graph: LocalEvidenceRetriever | None) -> dict | None:
"""지식그래프에서 POI명 검색 → 지역/카테고리 + 도보 근접 대안 근거.
그래프 미설정이거나 매칭 실패(대상 지역 밖 POI 등) 시 None — 프롬프트에 노이즈를 넣지 않는다.
@@ -202,7 +212,7 @@ def _graph_context(poi_name: str, graph: GraphRetriever | None) -> dict | None:
return ctx
-def _find_alternatives(poi_name: str, graph: GraphRetriever | None) -> list[AlternativePOI]:
+def _find_alternatives(poi_name: str, graph: LocalEvidenceRetriever | None) -> list[AlternativePOI]:
"""지식그래프에서 POI명 검색 → 도보 근접 대안 POI 목록. 미매칭/미설정 시 빈 리스트."""
if not poi_name or graph is None or not graph.enabled:
return []
@@ -220,7 +230,7 @@ def _build_user_prompt(
scores: Scores | None,
plan: ItineraryPlan,
final_score: int,
- graph: GraphRetriever | None = None,
+ graph: LocalEvidenceRetriever | None = None,
) -> str:
issues: list[dict] = []
@@ -236,12 +246,14 @@ def _build_user_prompt(
gctx = _graph_context(hf.poi_name or "", graph)
if gctx:
data["지식그래프_근거"] = gctx
- issues.append({
- "item_type": "hard_fail",
- "item_key": hf.fail_type,
- "day_index": hf.day_index,
- "data": data,
- })
+ issues.append(
+ {
+ "item_type": "hard_fail",
+ "item_key": hf.fail_type,
+ "day_index": hf.day_index,
+ "data": data,
+ }
+ )
for w in warnings:
data = {
@@ -255,36 +267,42 @@ def _build_user_prompt(
gctx = _graph_context(w.poi_names[0], graph)
if gctx:
data["지식그래프_근거"] = gctx
- issues.append({
- "item_type": "warning",
- "item_key": w.warning_type,
- "day_index": w.day_index,
- "data": data,
- })
+ issues.append(
+ {
+ "item_type": "warning",
+ "item_key": w.warning_type,
+ "day_index": w.day_index,
+ "data": data,
+ }
+ )
for key, penalty in penalty_breakdown.items():
- issues.append({
- "item_type": "penalty",
- "item_key": key,
- "data": {
- "감점": penalty,
- "규칙_설명": _PENALTY_RULES.get(key, key),
- },
- })
+ issues.append(
+ {
+ "item_type": "penalty",
+ "item_key": key,
+ "data": {
+ "감점": penalty,
+ "규칙_설명": _PENALTY_RULES.get(key, key),
+ },
+ }
+ )
passed = final_score >= 60 and not hard_fails
- issues.append({
- "item_type": "overall",
- "item_key": "summary",
- "data": {
- "최종_점수": final_score,
- "합격_여부": "PASS" if passed else "FAIL",
- "Hard_Fail_수": len(hard_fails),
- "Warning_수": len(warnings),
- "총_감점": sum(penalty_breakdown.values()),
- "총_가산": sum(bonus_breakdown.values()),
- },
- })
+ issues.append(
+ {
+ "item_type": "overall",
+ "item_key": "summary",
+ "data": {
+ "최종_점수": final_score,
+ "합격_여부": "PASS" if passed else "FAIL",
+ "Hard_Fail_수": len(hard_fails),
+ "Warning_수": len(warnings),
+ "총_감점": sum(penalty_breakdown.values()),
+ "총_가산": sum(bonus_breakdown.values()),
+ },
+ }
+ )
plan_info = {
"파티": f"{plan.party_type} {plan.party_size}인",
@@ -332,21 +350,23 @@ def _parse_llm_response(raw: str) -> list[ExplanationItem]:
text = raw.strip()
if text.startswith("```"):
lines = text.split("\n")
- end = next((i for i, l in enumerate(lines[1:], 1) if l.strip() == "```"), len(lines))
+ end = next((i for i, line in enumerate(lines[1:], 1) if line.strip() == "```"), len(lines))
text = "\n".join(lines[1:end])
data = json.loads(text)
items: list[ExplanationItem] = []
for obj in data:
- items.append(ExplanationItem(
- item_type=obj.get("item_type", "overall"),
- item_key=obj.get("item_key", "unknown"),
- fact=str(obj.get("fact", "")),
- rule=str(obj.get("rule", "")),
- risk=obj.get("risk", "WARNING"),
- suggestion=str(obj.get("suggestion", "")),
- day_index=obj.get("day_index"),
- ))
+ items.append(
+ ExplanationItem(
+ item_type=obj.get("item_type", "overall"),
+ item_key=obj.get("item_key", "unknown"),
+ fact=str(obj.get("fact", "")),
+ rule=str(obj.get("rule", "")),
+ risk=obj.get("risk", "WARNING"),
+ suggestion=str(obj.get("suggestion", "")),
+ day_index=obj.get("day_index"),
+ )
+ )
return items
@@ -360,55 +380,63 @@ def _fallback(
for hf in hard_fails:
day_prefix = f"{hf.day_index + 1}일차: " if hf.day_index is not None else ""
- items.append(ExplanationItem(
- item_type="hard_fail",
- item_key=hf.fail_type,
- fact=f"{day_prefix}[{hf.poi_name or '장소'}] {hf.message} (증거: {hf.evidence})",
- rule=_HARD_FAIL_RULES.get(hf.fail_type, hf.message),
- risk="CRITICAL",
- suggestion=_HARD_FAIL_SUGGESTIONS.get(hf.fail_type, "일정을 수정하세요."),
- day_index=hf.day_index,
- ))
+ items.append(
+ ExplanationItem(
+ item_type="hard_fail",
+ item_key=hf.fail_type,
+ fact=f"{day_prefix}[{hf.poi_name or '장소'}] {hf.message} (증거: {hf.evidence})",
+ rule=_HARD_FAIL_RULES.get(hf.fail_type, hf.message),
+ risk="CRITICAL",
+ suggestion=_HARD_FAIL_SUGGESTIONS.get(hf.fail_type, "일정을 수정하세요."),
+ day_index=hf.day_index,
+ )
+ )
for w in warnings:
day_prefix = f"{w.day_index + 1}일차: " if w.day_index is not None else ""
- items.append(ExplanationItem(
- item_type="warning",
- item_key=w.warning_type,
- fact=f"{day_prefix}{w.message}",
- rule=_WARNING_RULES.get(w.warning_type, w.message),
- risk="WARNING",
- suggestion=_WARNING_SUGGESTIONS.get(w.warning_type, "일정을 조정하세요."),
- day_index=w.day_index,
- ))
+ items.append(
+ ExplanationItem(
+ item_type="warning",
+ item_key=w.warning_type,
+ fact=f"{day_prefix}{w.message}",
+ rule=_WARNING_RULES.get(w.warning_type, w.message),
+ risk="WARNING",
+ suggestion=_WARNING_SUGGESTIONS.get(w.warning_type, "일정을 조정하세요."),
+ day_index=w.day_index,
+ )
+ )
for key, penalty in penalty_breakdown.items():
- items.append(ExplanationItem(
- item_type="penalty",
- item_key=key,
- fact=f"{key} 패널티 {penalty}점 감점",
- rule=_PENALTY_RULES.get(key, ""),
- risk="CRITICAL" if penalty > 5 else "WARNING",
- suggestion=_PENALTY_SUGGESTIONS.get(key, "동선을 최적화하세요."),
- ))
+ items.append(
+ ExplanationItem(
+ item_type="penalty",
+ item_key=key,
+ fact=f"{key} 패널티 {penalty}점 감점",
+ rule=_PENALTY_RULES.get(key, ""),
+ risk="CRITICAL" if penalty > 5 else "WARNING",
+ suggestion=_PENALTY_SUGGESTIONS.get(key, "동선을 최적화하세요."),
+ )
+ )
passed = final_score >= 60 and not hard_fails
- items.append(ExplanationItem(
- item_type="overall",
- item_key="summary",
- fact=(
- f"종합 점수 {final_score}/100 — "
- f"Hard Fail {len(hard_fails)}건, Warning {len(warnings)}건, "
- f"패널티 {sum(penalty_breakdown.values())}점"
- ),
- rule="60점 이상이면 PASS. Hard Fail 존재 시 점수는 59점 이하로 제한됩니다.",
- risk="OK" if passed else "CRITICAL",
- suggestion=(
- "일정이 기준을 통과했습니다. 경고 항목을 개선하면 더 나은 여행이 됩니다."
- if passed else
- "Hard Fail을 먼저 해결한 후, Warning 항목을 순서대로 개선하세요."
- ),
- ))
+ items.append(
+ ExplanationItem(
+ item_type="overall",
+ item_key="summary",
+ fact=(
+ f"종합 점수 {final_score}/100 — "
+ f"Hard Fail {len(hard_fails)}건, Warning {len(warnings)}건, "
+ f"패널티 {sum(penalty_breakdown.values())}점"
+ ),
+ rule="60점 이상이면 PASS. Hard Fail 존재 시 점수는 59점 이하로 제한됩니다.",
+ risk="OK" if passed else "CRITICAL",
+ suggestion=(
+ "일정이 기준을 통과했습니다. 경고 항목을 개선하면 더 나은 여행이 됩니다."
+ if passed
+ else "Hard Fail을 먼저 해결한 후, Warning 항목을 순서대로 개선하세요."
+ ),
+ )
+ )
return items
@@ -423,17 +451,20 @@ def __init__(
timeout_sec: float = DEFAULT_TIMEOUT_SEC,
max_tokens: int = DEFAULT_MAX_TOKENS,
client: Any = None,
- graph_retriever: GraphRetriever | None = None,
+ graph_retriever: LocalEvidenceRetriever | None = None,
) -> None:
self._model = model
self._timeout = timeout_sec
self._max_tokens = max_tokens
- self._api_key = api_key or os.environ.get("ANTHROPIC_API_KEY", "")
+ self._api_key = Settings().anthropic_api_key if api_key is None else api_key
self._client = client
if self._client is None and _ANTHROPIC_AVAILABLE and self._api_key:
self._client = anthropic.Anthropic(api_key=self._api_key)
- # NEO4J_URI 미설정 시 GraphRetriever.enabled=False → 그래프 근거는 조용히 생략된다.
- self._graph = graph_retriever if graph_retriever is not None else GraphRetriever.from_env()
+ self._graph = (
+ graph_retriever
+ if graph_retriever is not None
+ else LocalEvidenceRetriever.from_settings()
+ )
def is_available(self) -> bool:
return self._client is not None
@@ -491,18 +522,22 @@ def generate(
if improvement_hints:
suggestion = f"{'·'.join(improvement_hints)}으로 점수를 추가로 높일 수 있습니다."
elif final_score < 85:
- suggestion = "웰니스·무장애 장소를 추가하면 보너스 가산점으로 점수를 더 높일 수 있습니다."
+ suggestion = (
+ "웰니스·무장애 장소를 추가하면 보너스 가산점으로 점수를 더 높일 수 있습니다."
+ )
else:
suggestion = "완성도 높은 일정입니다. 현재 구성을 유지하세요."
- return [ExplanationItem(
- item_type="overall",
- item_key="summary",
- fact=", ".join(fact_parts),
- rule="60점 이상이면 PASS. Hard Fail 없이 모든 항목을 통과했습니다.",
- risk="OK",
- suggestion=suggestion,
- )]
+ return [
+ ExplanationItem(
+ item_type="overall",
+ item_key="summary",
+ fact=", ".join(fact_parts),
+ rule="60점 이상이면 PASS. Hard Fail 없이 모든 항목을 통과했습니다.",
+ risk="OK",
+ suggestion=suggestion,
+ )
+ ]
# 폴백 (LLM 미사용)
if not self.is_available():
@@ -515,8 +550,13 @@ def generate(
try:
result = self._call_llm(
- hard_fails, warnings, penalty_breakdown, bonus_breakdown,
- scores, plan, final_score,
+ hard_fails,
+ warnings,
+ penalty_breakdown,
+ bonus_breakdown,
+ scores,
+ plan,
+ final_score,
)
_CACHE[key] = result
return result
@@ -534,8 +574,13 @@ def _call_llm(
final_score: int,
) -> list[ExplanationItem]:
user_prompt = _build_user_prompt(
- hard_fails, warnings, penalty_breakdown,
- bonus_breakdown, scores, plan, final_score,
+ hard_fails,
+ warnings,
+ penalty_breakdown,
+ bonus_breakdown,
+ scores,
+ plan,
+ final_score,
graph=self._graph,
)
@@ -543,11 +588,13 @@ def _call_llm(
model=self._model,
max_tokens=self._max_tokens,
timeout=self._timeout,
- system=[{
- "type": "text",
- "text": SYSTEM_PROMPT,
- "cache_control": {"type": "ephemeral"},
- }],
+ system=[
+ {
+ "type": "text",
+ "text": SYSTEM_PROMPT,
+ "cache_control": {"type": "ephemeral"},
+ }
+ ],
messages=[{"role": "user", "content": user_prompt}],
)
diff --git a/src/explain/pipeline.py b/src/explain/pipeline.py
index 8cd19a8..b79b96a 100644
--- a/src/explain/pipeline.py
+++ b/src/explain/pipeline.py
@@ -18,6 +18,7 @@
adjusted = clamp(adjusted, 0, 100)
if hard_fails: adjusted = min(adjusted, 59)
"""
+
from __future__ import annotations
import dataclasses
@@ -43,11 +44,12 @@
from src.scoring.travel_ratio import evaluate_travel_ratio
from src.validation.hard_fail import HardFailDetector
from src.validation.scoring import ScoreCalculator
-from src.validation.vrptw_engine import VRPTWEngine
+from src.validation.vrptw_engine import TimeMatrix, VRPTWEngine
from src.validation.warning import WarningDetector
-_DEFAULT_WELLNESS_PATH = Path("data/wellness_places.json")
-_DEFAULT_BARRIER_FREE_PATH = Path("data/barrier_free_places.json")
+_PROJECT_ROOT = Path(__file__).resolve().parents[2]
+_DEFAULT_WELLNESS_PATH = _PROJECT_ROOT / "data" / "wellness_places.json"
+_DEFAULT_BARRIER_FREE_PATH = _PROJECT_ROOT / "data" / "barrier_free_places.json"
def _to_vrptw_day(pois: list[POI]) -> VRPTWDay:
@@ -82,6 +84,7 @@ def _to_poi_with_category(pois: list[POI], order_offset: int = 0) -> list[POIWit
@dataclasses.dataclass
class _ScoreBundle:
"""1·3·3b·4·5·6·7·8단계(점수 계산)만의 결과. Warning·Repair·Explain 미포함."""
+
adjusted: int
base_score: int
scores: Scores
@@ -124,6 +127,7 @@ def run(
sigungu_codes_per_day: list[list[str]] | None = None,
user_prefs: UserPreferences | None = None,
pet_friendly_enabled: bool = False,
+ time_matrix: TimeMatrix | None = None,
) -> ValidationResult:
"""파이프라인 실행 → ValidationResult 반환.
@@ -137,8 +141,13 @@ def run(
"""
all_pois: list[POI] = [poi for day in per_day_pois for poi in day]
bundle = self._score(
- plan, per_day_pois, matrix,
- sigungu_codes_per_day, user_prefs, pet_friendly_enabled,
+ plan,
+ per_day_pois,
+ matrix,
+ sigungu_codes_per_day,
+ user_prefs,
+ pet_friendly_enabled,
+ time_matrix,
)
# ── 2. Warning 탐지 (per-day) ────────────────────────────────────
@@ -149,15 +158,15 @@ def run(
for day_idx, day_pois in enumerate(per_day_pois):
if not day_pois:
continue
- day_warns = self._warning.detect(plan=plan, pois=day_pois, matrix=matrix, day_index=day_idx)
+ day_warns = self._warning.detect(
+ plan=plan, pois=day_pois, matrix=matrix, day_index=day_idx
+ )
warnings.extend(w for w in day_warns if w.warning_type != "PURPOSE_MISMATCH")
warnings.extend(self._warning._check_purpose_mismatch(plan, all_pois))
# CUMULATIVE_FATIGUE — cross-day 분석 (2일 이상 일정에서만 의미 있음)
- warnings.extend(
- self._warning.check_cumulative_fatigue(plan, per_day_pois, matrix)
- )
+ warnings.extend(self._warning.check_cumulative_fatigue(plan, per_day_pois, matrix))
rewards = generate_rewards(
scores=bundle.scores,
@@ -196,7 +205,12 @@ def run(
)
if not repair_result.is_empty:
repair_result = self._estimate_repair_gains(
- plan, per_day_pois, matrix, pet_friendly_enabled, repair_result,
+ plan,
+ per_day_pois,
+ matrix,
+ pet_friendly_enabled,
+ repair_result,
+ time_matrix=time_matrix,
)
repair_data = repair_result.to_dict()
@@ -212,7 +226,9 @@ def run(
)
# ── 12. Hard Fail POI 대안 (지식그래프 도보권 대안, 미설정/미매칭 시 빈 dict) ──
- alternatives = self._explain.build_alternatives(bundle.hard_fails) if bundle.hard_fails else {}
+ alternatives = (
+ self._explain.build_alternatives(bundle.hard_fails) if bundle.hard_fails else {}
+ )
return ValidationResult(
plan_id=plan.plan_id,
@@ -240,6 +256,7 @@ def _score(
sigungu_codes_per_day: list[list[str]] | None,
user_prefs: UserPreferences | None,
pet_friendly_enabled: bool,
+ time_matrix: TimeMatrix | None = None,
) -> _ScoreBundle:
"""1·3·3b·4·5·6·7·8단계만 실행해 점수를 계산한다 (Warning·Repair·Explain 제외).
@@ -267,12 +284,18 @@ def _score(
# ── 3. ScoreCalculator → base_score ────────────────────────────
if all_pois:
scores, base_score = self._scorer.compute(
- plan=plan, pois=all_pois, matrix=matrix, hard_fails=hard_fails,
+ plan=plan,
+ pois=all_pois,
+ matrix=matrix,
+ hard_fails=hard_fails,
)
else:
scores = Scores(
- efficiency=0.0, feasibility=0.0,
- purpose_fit=0.0, flow=0.0, area_intensity=0.0,
+ efficiency=0.0,
+ feasibility=0.0,
+ purpose_fit=0.0,
+ flow=0.0,
+ area_intensity=0.0,
)
base_score = 0
@@ -283,7 +306,9 @@ def _score(
vrptw_penalty = 0
if vrptw_days:
- _vrptw_result = VRPTWEngine().validate(VRPTWRequest(days=vrptw_days))
+ _vrptw_result = VRPTWEngine(matrix=time_matrix).validate(
+ VRPTWRequest(days=vrptw_days, start_time=plan.start_time)
+ )
vrptw_optimal_route = _vrptw_result.optimal_route
vrptw_efficiency_gap = _vrptw_result.efficiency_gap
if vrptw_efficiency_gap is not None:
@@ -304,7 +329,7 @@ def _score(
travel_ratio_penalty = 0
overall_travel_ratio = 0.0
if vrptw_days:
- tr_report = evaluate_travel_ratio(vrptw_days)
+ tr_report = evaluate_travel_ratio(vrptw_days, matrix=time_matrix)
travel_ratio_penalty = tr_report.total_penalty
overall_travel_ratio = tr_report.overall_ratio
@@ -317,7 +342,8 @@ def _score(
# ── 7. BonusEngine 가산점 ───────────────────────────────────────
bonus_result = self._bonus.compute(
- pois=all_pois, party_type=plan.party_type,
+ pois=all_pois,
+ party_type=plan.party_type,
pet_friendly_enabled=pet_friendly_enabled,
)
@@ -353,6 +379,7 @@ def _estimate_repair_gains(
matrix: dict,
pet_friendly_enabled: bool,
repair_result: RepairResult,
+ time_matrix: TimeMatrix | None = None,
) -> RepairResult:
"""교정 제안별 예상 점수 변화(`estimated_score_gain`)와 문제 해소 여부(`resolves_hard_fail`)를 채운다.
@@ -363,18 +390,26 @@ def _estimate_repair_gains(
정밀도가 필요해지면 실제 sigungu_codes_per_day·user_prefs를 그대로 전달하도록 확장한다.
"""
baseline = self._score(
- plan, per_day_pois, matrix,
- sigungu_codes_per_day=None, user_prefs=None,
+ plan,
+ per_day_pois,
+ matrix,
+ sigungu_codes_per_day=None,
+ user_prefs=None,
pet_friendly_enabled=pet_friendly_enabled,
+ time_matrix=time_matrix,
)
def simulate(day_idx: int, modified_day: list[POI]) -> tuple[int, bool]:
sim_days = list(per_day_pois)
sim_days[day_idx] = modified_day
bundle = self._score(
- plan, sim_days, matrix,
- sigungu_codes_per_day=None, user_prefs=None,
+ plan,
+ sim_days,
+ matrix,
+ sigungu_codes_per_day=None,
+ user_prefs=None,
pet_friendly_enabled=pet_friendly_enabled,
+ time_matrix=time_matrix,
)
resolved = not any(hf.day_index == day_idx for hf in bundle.capping_fails)
return bundle.adjusted - baseline.adjusted, resolved
@@ -384,28 +419,41 @@ def simulate(day_idx: int, modified_day: list[POI]) -> tuple[int, bool]:
by_name = {p.name: p for p in per_day_pois[ro.day_index]}
modified = [by_name[n] for n in ro.suggested_order if n in by_name]
gain, resolved = simulate(ro.day_index, modified)
- reorders.append(dataclasses.replace(
- ro, estimated_score_gain=gain, resolves_hard_fail=resolved,
- ))
+ reorders.append(
+ dataclasses.replace(
+ ro,
+ estimated_score_gain=gain,
+ resolves_hard_fail=resolved,
+ )
+ )
time_tunes = []
for tt in repair_result.time_tunes:
modified = [
p.model_copy(update={"duration_min": tt.adjustments[p.name]})
- if p.name in tt.adjustments else p
+ if p.name in tt.adjustments
+ else p
for p in per_day_pois[tt.day_index]
]
gain, resolved = simulate(tt.day_index, modified)
- time_tunes.append(dataclasses.replace(
- tt, estimated_score_gain=gain, resolves_hard_fail=resolved,
- ))
+ time_tunes.append(
+ dataclasses.replace(
+ tt,
+ estimated_score_gain=gain,
+ resolves_hard_fail=resolved,
+ )
+ )
deletions = []
for dl in repair_result.deletions:
modified = [p for p in per_day_pois[dl.day_index] if p.name != dl.candidate_name]
gain, resolved = simulate(dl.day_index, modified)
- deletions.append(dataclasses.replace(
- dl, estimated_score_gain=gain, resolves_hard_fail=resolved,
- ))
+ deletions.append(
+ dataclasses.replace(
+ dl,
+ estimated_score_gain=gain,
+ resolves_hard_fail=resolved,
+ )
+ )
return RepairResult(reorders=reorders, time_tunes=time_tunes, deletions=deletions)
diff --git a/src/explain/plan_extractor.py b/src/explain/plan_extractor.py
index 2b67265..222e9c1 100644
--- a/src/explain/plan_extractor.py
+++ b/src/explain/plan_extractor.py
@@ -4,22 +4,24 @@
복사한 텍스트 — 을 입력받아 day/place 구조(ParsedPlanResponse)로 정규화한다.
텍스트는 쿼리 리라이팅으로, 이미지·PDF는 Claude Vision으로 동일한 JSON 스키마를 뽑아낸다.
-추출된 장소명은 이후 src.api.router._resolve_poi()가 지식그래프(GraphRetriever)·
-jeju_places.csv 등 기존 데이터 레이어를 그대로 통해 좌표·운영시간을 재조회하므로,
+추출된 장소명은 이후 src.api.router._resolve_poi()가 로컬 근거 리트리버·
+jeju_places.csv 등 기존 데이터 레이어를 통해 좌표·운영시간을 재조회하므로,
이 모듈은 "이름·주소·카테고리 추출"에만 집중한다.
"""
+
from __future__ import annotations
import base64
import json
-import os
import re
from typing import Any
from src.api.schemas import ParsedDay, ParsedPlace, ParsedPlanResponse
+from src.data.models import Settings
try:
import anthropic
+
_ANTHROPIC_AVAILABLE = True
except ImportError:
_ANTHROPIC_AVAILABLE = False
@@ -48,7 +50,9 @@
- 장소를 하나도 찾지 못하면 {"days": []} 를 반환하라.
"""
-_USER_PREFIX_TEXT = "다음은 여행 플래너에서 추천받은 일정을 복사한 텍스트다. 스키마에 맞게 파싱하라:\n\n"
+_USER_PREFIX_TEXT = (
+ "다음은 여행 플래너에서 추천받은 일정을 복사한 텍스트다. 스키마에 맞게 파싱하라:\n\n"
+)
_USER_PREFIX_DOC = "첨부된 여행 일정 캡처(이미지 또는 PDF)를 스키마에 맞게 파싱하라."
_FENCE_RE = re.compile(r"^```(?:json)?\s*|\s*```$", re.MULTILINE)
@@ -114,7 +118,7 @@ def __init__(
self._model = model
self._timeout = timeout_sec
self._max_tokens = max_tokens
- self._api_key = api_key or os.environ.get("ANTHROPIC_API_KEY", "")
+ self._api_key = Settings().anthropic_api_key if api_key is None else api_key
self._client = client
if self._client is None and _ANTHROPIC_AVAILABLE and self._api_key:
self._client = anthropic.Anthropic(api_key=self._api_key)
@@ -151,7 +155,6 @@ def extract_from_document(self, data: bytes, media_type: str) -> ParsedPlanRespo
{
"type": "text",
"text": _USER_PREFIX_DOC,
- "cache_control": {"type": "ephemeral"},
},
]
return self._call(content)
@@ -162,7 +165,13 @@ def _call(self, content: list[dict]) -> ParsedPlanResponse:
model=self._model,
max_tokens=self._max_tokens,
timeout=self._timeout,
- system=_SYSTEM_PROMPT,
+ system=[
+ {
+ "type": "text",
+ "text": _SYSTEM_PROMPT,
+ "cache_control": {"type": "ephemeral"},
+ }
+ ],
messages=[{"role": "user", "content": content}],
)
except Exception as e:
@@ -177,9 +186,13 @@ def _demo() -> None:
)
assert resp.days[0].places[0].name == "성산일출봉"
- fb = _fallback_text_parse("Day 1\n1 다려도 여행지\n2 바람벽에흰당나귀 카페\n\nDay 2\n월정리해변")
+ fb = _fallback_text_parse(
+ "Day 1\n1 다려도 여행지\n2 바람벽에흰당나귀 카페\n\nDay 2\n월정리해변"
+ )
assert [p.name for d in fb.days for p in d.places] == [
- "다려도", "바람벽에흰당나귀", "월정리해변",
+ "다려도",
+ "바람벽에흰당나귀",
+ "월정리해변",
]
assert len(fb.days) == 2
print("plan_extractor self-check OK")
diff --git a/src/explain/repair.py b/src/explain/repair.py
index 2d162cd..20f3698 100644
--- a/src/explain/repair.py
+++ b/src/explain/repair.py
@@ -8,6 +8,7 @@
이 엔진은 '장소 대체(substitution)'를 수행하지 않는다.
사용자가 선택한 POI 목록을 보존하며 제약 조건만을 최적화하는 수학적 교정 도구다.
"""
+
from __future__ import annotations
import dataclasses
@@ -22,9 +23,9 @@
from src.utils.geo import build_dist_cache, get_travel_min, haversine_km
from src.validation.hard_fail import HardFailDetector
-_MAX_PERM_N: int = 7 # 7! = 5040 — 탐색 허용 상한
-_MIN_DWELL_RATIO: float = 0.5 # 최소 체류 = 원래의 50%
-_MIN_DWELL_ABS: int = 20 # 절대 최솟값 20분
+_MAX_PERM_N: int = 7 # 7! = 5040 — 탐색 허용 상한
+_MIN_DWELL_RATIO: float = 0.5 # 최소 체류 = 원래의 50%
+_MIN_DWELL_ABS: int = 20 # 절대 최솟값 20분
def _norm(name: str) -> str:
@@ -80,8 +81,22 @@ class RepairResult:
def is_empty(self) -> bool:
return not (self.reorders or self.time_tunes or self.deletions)
+ @property
+ def total_estimated_gain(self) -> int:
+ """모든 제안을 적용했을 때 예상 총 점수 상승분.
+
+ 같은 날짜의 제안들은 서로 대안(하나만 적용)이므로 최댓값만 취하고,
+ 서로 다른 날짜의 제안은 독립적이므로 합산한다.
+ """
+ per_day: dict[int, int] = {}
+ for sug in (*self.reorders, *self.time_tunes, *self.deletions):
+ per_day[sug.day_index] = max(per_day.get(sug.day_index, 0), sug.estimated_score_gain)
+ return sum(per_day.values())
+
def to_dict(self) -> dict:
- return dataclasses.asdict(self)
+ d = dataclasses.asdict(self)
+ d["total_estimated_gain"] = self.total_estimated_gain
+ return d
class RepairEngine:
@@ -194,8 +209,7 @@ def _try_time_tune(
return None
saved = sum(
- poi.duration_min - adjustments[poi.name]
- for poi in pois if poi.name in adjustments
+ poi.duration_min - adjustments[poi.name] for poi in pois if poi.name in adjustments
)
return TimeTuneSuggestion(
day_index=day_idx,
@@ -224,7 +238,7 @@ def _suggest_deletion(
max_savings = -1.0
best_idx = -1
- for i, poi in enumerate(pois):
+ for i, _poi in enumerate(pois):
before = pois[i - 1] if i > 0 else None
after = pois[i + 1] if i < len(pois) - 1 else None
@@ -236,7 +250,8 @@ def _suggest_deletion(
bypass = (
haversine_km(before.lat, before.lng, after.lat, after.lng)
- if before and after else 0.0
+ if before and after
+ else 0.0
)
savings = detour - bypass
@@ -256,7 +271,9 @@ def _suggest_deletion(
)
if nearby:
reason += (
- " 대신 근처 음식점 " + ", ".join(f"{a.name}({a.distance_km}km)" for a in nearby) + "을(를) 추천합니다."
+ " 대신 근처 음식점 "
+ + ", ".join(f"{a.name}({a.distance_km}km)" for a in nearby)
+ + "을(를) 추천합니다."
)
else:
reason += " 반경 2km 내 대체 가능한 음식점을 찾지 못했습니다."
diff --git a/src/matrix/__init__.py b/src/matrix/__init__.py
index 56477fe..a59d6cc 100644
--- a/src/matrix/__init__.py
+++ b/src/matrix/__init__.py
@@ -1,4 +1,5 @@
"""matrix — 이동시간 행렬 구현체 패키지."""
+
from src.matrix.redis_matrix import RedisTimeMatrix
__all__ = ["RedisTimeMatrix"]
diff --git a/src/matrix/redis_matrix.py b/src/matrix/redis_matrix.py
index 804accf..025fdd0 100644
--- a/src/matrix/redis_matrix.py
+++ b/src/matrix/redis_matrix.py
@@ -13,17 +13,18 @@
if matrix is None:
matrix = KakaoMobilityMatrix.from_env(cache_path="data/route_cache.json")
"""
+
from __future__ import annotations
import os
from pathlib import Path
-from typing import Any
from src.data.models import VRPTWPlace
from src.validation.vrptw_engine import HaversineMatrix, TimeMatrix
try:
import redis as _redis_lib
+
_REDIS_AVAILABLE = True
except ImportError:
_REDIS_AVAILABLE = False
@@ -42,13 +43,14 @@ class RedisTimeMatrix(TimeMatrix):
def __init__(self, redis_url: str) -> None:
if not _REDIS_AVAILABLE:
- raise RuntimeError(
- "redis-py 미설치. `pip install redis` 후 사용하세요."
- )
+ raise RuntimeError("redis-py 미설치. `pip install redis` 후 사용하세요.")
self._client = _redis_lib.from_url(redis_url, decode_responses=True)
self._fallback = HaversineMatrix()
self._stats: dict[str, int] = {
- "cache_hit": 0, "cache_miss": 0, "fallback": 0, "write": 0,
+ "cache_hit": 0,
+ "cache_miss": 0,
+ "fallback": 0,
+ "write": 0,
}
# ── 팩토리 ───────────────────────────────────────────────────────────
@@ -56,7 +58,7 @@ def __init__(self, redis_url: str) -> None:
def from_env(
cls,
env_path: str | Path | None = None,
- ) -> "RedisTimeMatrix | None":
+ ) -> RedisTimeMatrix | None:
"""REDIS_URL 환경변수가 있으면 인스턴스 반환, 없으면 None."""
if env_path:
cls._load_dotenv(Path(env_path))
diff --git a/src/matrix/route_matrix.py b/src/matrix/route_matrix.py
new file mode 100644
index 0000000..6500837
--- /dev/null
+++ b/src/matrix/route_matrix.py
@@ -0,0 +1,93 @@
+"""운영 검증에 주입할 indexed 이동시간 행렬 서비스."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from src.data.models import POI, Settings, VRPTWPlace
+from src.utils.geo import haversine_km
+from src.validation.kakao_matrix import KakaoMobilityMatrix
+from src.validation.vrptw_engine import HaversineMatrix, TimeMatrix
+
+
+class RouteMatrixService:
+ """Kakao Mobility를 우선 사용하고 보정된 Haversine으로 폴백한다."""
+
+ def __init__(self, provider: TimeMatrix, mode: str | None = None):
+ self.provider = provider
+ self._mode = mode or (
+ "kakao" if isinstance(provider, KakaoMobilityMatrix) else "haversine_fallback"
+ )
+
+ @classmethod
+ def from_settings(
+ cls,
+ settings: Settings | None = None,
+ cache_path: str | Path | None = None,
+ ) -> RouteMatrixService:
+ settings = settings or Settings()
+ api_key = settings.kakao_mobility_key or settings.kakao_rest_api_key
+ if not api_key:
+ return cls(HaversineMatrix())
+
+ if cache_path is None:
+ cache_path = Path(__file__).resolve().parents[2] / "data" / "route_cache.json"
+ return cls(KakaoMobilityMatrix(api_key=api_key, cache_path=cache_path))
+
+ @property
+ def uses_kakao(self) -> bool:
+ return isinstance(self.provider, KakaoMobilityMatrix)
+
+ @staticmethod
+ def _to_vrptw_place(poi: POI) -> VRPTWPlace:
+ return VRPTWPlace(
+ name=poi.name,
+ lat=poi.lat,
+ lng=poi.lng,
+ open=poi.open_start,
+ close=poi.open_end,
+ stay_duration=poi.duration_min,
+ )
+
+ async def prepare(self, pois: list[POI]) -> None:
+ """현재 요청의 모든 장소 쌍을 API/캐시에 미리 적재한다."""
+ places = [self._to_vrptw_place(poi) for poi in pois]
+ if hasattr(self.provider, "aprefetch_matrix") and len(places) > 1:
+ await self.provider.aprefetch_matrix(places) # type: ignore[attr-defined]
+
+ def get_travel_time(self, origin: VRPTWPlace, destination: VRPTWPlace) -> int:
+ """VRPTWEngine이 사용하는 초 단위 이동시간."""
+ return self.provider.get_travel_time(origin, destination)
+
+ def get_travel_min(self, origin: POI, destination: POI) -> float:
+ """기존 dict 기반 검증기가 사용하는 분 단위 이동시간."""
+ return (
+ self.provider.get_travel_time(
+ self._to_vrptw_place(origin),
+ self._to_vrptw_place(destination),
+ )
+ / 60.0
+ )
+
+ async def build(self, pois: list[POI]) -> dict[int, dict[int, dict[str, float | str]]]:
+ places = [self._to_vrptw_place(poi) for poi in pois]
+ await self.prepare(pois)
+
+ mode = self._mode
+ matrix: dict[int, dict[int, dict[str, float | str]]] = {}
+ for i, origin in enumerate(places):
+ for j, destination in enumerate(places):
+ if i == j:
+ continue
+ seconds = self.provider.get_travel_time(origin, destination)
+ matrix.setdefault(i, {})[j] = {
+ "travel_min": seconds / 60.0,
+ "distance_km": haversine_km(
+ origin.lat,
+ origin.lng,
+ destination.lat,
+ destination.lng,
+ ),
+ "mode": mode,
+ }
+ return matrix
diff --git a/src/scoring/bonus_engine.py b/src/scoring/bonus_engine.py
index a1f0a83..646cd87 100644
--- a/src/scoring/bonus_engine.py
+++ b/src/scoring/bonus_engine.py
@@ -1,4 +1,5 @@
"""가산점 엔진 — 웰니스·무장애 여행지 방문 보너스."""
+
from __future__ import annotations
import json
@@ -25,9 +26,9 @@ class BonusResult:
accessibility_bonus: int
pet_friendly_bonus: int
total_bonus: int
- wellness_matched: list[str] # 매칭된 POI 이름 목록
- accessibility_matched: list[str] # 매칭된 POI 이름 목록
- pet_friendly_matched: list[str] # 매칭된 POI 이름 목록
+ wellness_matched: list[str] # 매칭된 POI 이름 목록
+ accessibility_matched: list[str] # 매칭된 POI 이름 목록
+ pet_friendly_matched: list[str] # 매칭된 POI 이름 목록
@dataclass(frozen=True)
@@ -56,7 +57,7 @@ def from_dataset(
cls,
wellness_path: Path | str = "data/wellness_places.json",
barrier_free_path: Path | str = "data/barrier_free_places.json",
- ) -> "BonusEngine":
+ ) -> BonusEngine:
"""로컬 JSON 데이터셋에서 로드. 파일 없으면 빈 엔진 반환."""
wellness: list[_PlaceCoord] = []
barrier_free: list[_PlaceCoord] = []
@@ -107,18 +108,14 @@ def compute(
if pet_friendly_enabled and poi.pet_friendly:
pet_friendly_matched.append(poi.name)
- wellness_bonus = min(
- len(wellness_matched) * WELLNESS_BONUS_PER_PLACE, BONUS_CAP
- )
+ wellness_bonus = min(len(wellness_matched) * WELLNESS_BONUS_PER_PLACE, BONUS_CAP)
accessibility_bonus = min(
len(accessibility_matched) * ACCESSIBILITY_BONUS_PER_PLACE, BONUS_CAP
)
pet_friendly_bonus = min(
len(pet_friendly_matched) * PET_FRIENDLY_BONUS_PER_PLACE, BONUS_CAP
)
- total_bonus = min(
- wellness_bonus + accessibility_bonus + pet_friendly_bonus, BONUS_CAP
- )
+ total_bonus = min(wellness_bonus + accessibility_bonus + pet_friendly_bonus, BONUS_CAP)
return BonusResult(
wellness_bonus=wellness_bonus,
diff --git a/src/scoring/cluster_dispersion.py b/src/scoring/cluster_dispersion.py
index d1fb8f8..1025eb8 100644
--- a/src/scoring/cluster_dispersion.py
+++ b/src/scoring/cluster_dispersion.py
@@ -14,9 +14,10 @@
eps=2.0km (도보 25분). sklearn 없으면 자동 스킵.
per-request 즉석 계산 (4~8 POI → <1ms, DB 사전 클러스터링 불필요).
"""
+
from __future__ import annotations
-from dataclasses import dataclass, field
+from dataclasses import dataclass
from src.data.models import DeepDiveItem, VRPTWDay, VRPTWPlace
from src.utils.geo import haversine_km as _haversine_km
@@ -24,6 +25,7 @@
try:
import numpy as np
from sklearn.cluster import DBSCAN as _DBSCAN
+
_SKLEARN_AVAILABLE = True
except ImportError:
_SKLEARN_AVAILABLE = False
@@ -55,7 +57,7 @@
GEO_BT_CRIT: int = 2
PENALTY_GEO_BT_WARN: int = 5
PENALTY_GEO_BT_CRIT: int = 10
-DBSCAN_EPS_KM: float = 2.0 # 도보 25분 ≈ 2km
+DBSCAN_EPS_KM: float = 2.0 # 도보 25분 ≈ 2km
# ── 합산 캡 ──────────────────────────────────────────────────────────
COMBINED_PENALTY_CAP: int = 20
@@ -104,21 +106,22 @@ def count_geo_cluster_backtracks(
return 0
coords = np.radians([[p.lat, p.lng] for p in places])
eps_rad = eps_km / _EARTH_R_KM
- labels: list[int] = _DBSCAN(
- eps=eps_rad, min_samples=1, metric="haversine"
- ).fit_predict(coords).tolist()
+ labels: list[int] = (
+ _DBSCAN(eps=eps_rad, min_samples=1, metric="haversine").fit_predict(coords).tolist()
+ )
return _count_label_backtracks(labels)
@dataclass(frozen=True)
class DayDispersionMetric:
"""일자별 밀집도 측정."""
+
day_index: int
sigungu_switches: int
max_pairwise_km: float
sigungu_codes_visited: list[str]
- area_backtrack_count: int = 0 # M3 시군구 기반
- geo_cluster_backtrack: int = 0 # M4 DBSCAN 지리 기반
+ area_backtrack_count: int = 0 # M3 시군구 기반
+ geo_cluster_backtrack: int = 0 # M4 DBSCAN 지리 기반
@dataclass(frozen=True)
@@ -136,7 +139,7 @@ def _compute_day_dispersion(
"""하루 일정의 네 메트릭 계산."""
# ── M1 ──
sigungus: list[str] = [c for c in (sigungu_codes or []) if c]
- switches = sum(1 for a, b in zip(sigungus, sigungus[1:]) if a != b)
+ switches = sum(1 for a, b in zip(sigungus, sigungus[1:], strict=False) if a != b)
# ── M2 ──
max_dist = 0.0
@@ -212,71 +215,82 @@ def evaluate_cluster_dispersion(
total_penalty = 0
for idx, day in enumerate(days):
- sg = sigungu_codes_per_day[idx] if sigungu_codes_per_day and idx < len(sigungu_codes_per_day) else None
+ sg = (
+ sigungu_codes_per_day[idx]
+ if sigungu_codes_per_day and idx < len(sigungu_codes_per_day)
+ else None
+ )
metric = _compute_day_dispersion(idx, day.places, sg)
per_day.append(metric)
- sw_pen = _switch_penalty(metric.sigungu_switches)
- ds_pen = _distance_penalty(metric.max_pairwise_km)
- bt_pen = _backtrack_penalty(metric.area_backtrack_count)
+ sw_pen = _switch_penalty(metric.sigungu_switches)
+ ds_pen = _distance_penalty(metric.max_pairwise_km)
+ bt_pen = _backtrack_penalty(metric.area_backtrack_count)
geo_pen = _geo_bt_penalty(metric.geo_cluster_backtrack, metric.area_backtrack_count)
day_penalty = min(sw_pen + ds_pen + bt_pen + geo_pen, COMBINED_PENALTY_CAP)
total_penalty += day_penalty
if bt_pen > 0:
- deep_dive.append(DeepDiveItem(
- fact=(
- f"{idx + 1}일차 구역 백트래킹 {metric.area_backtrack_count}회 탐지 "
- f"(이미 방문한 시군구에 다시 되돌아옴)"
- ),
- rule="area_backtrack",
- risk="WARNING" if bt_pen == PENALTY_BACKTRACK_WARN else "CRITICAL",
- suggestion=(
- "이미 방문한 지역으로 되돌아가는 동선이 있습니다. "
- "같은 구역 방문을 연속으로 묶어 이동 낭비를 줄이세요."
- ),
- ))
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"{idx + 1}일차 구역 백트래킹 {metric.area_backtrack_count}회 탐지 "
+ f"(이미 방문한 시군구에 다시 되돌아옴)"
+ ),
+ rule="area_backtrack",
+ risk="WARNING" if bt_pen == PENALTY_BACKTRACK_WARN else "CRITICAL",
+ suggestion=(
+ "이미 방문한 지역으로 되돌아가는 동선이 있습니다. "
+ "같은 구역 방문을 연속으로 묶어 이동 낭비를 줄이세요."
+ ),
+ )
+ )
if geo_pen > 0:
- deep_dive.append(DeepDiveItem(
- fact=(
- f"{idx + 1}일차 지리적 클러스터 백트래킹 {metric.geo_cluster_backtrack}회 탐지 "
- f"(같은 시군구 내 지리적으로 분산된 구역 간 왕복)"
- ),
- rule="geo_cluster_backtrack",
- risk="WARNING" if geo_pen == PENALTY_GEO_BT_WARN else "CRITICAL",
- suggestion=(
- "같은 행정구역 안에서도 멀리 떨어진 장소를 왕복하고 있습니다. "
- "인접한 장소끼리 묶어 방문 순서를 재배치하세요."
- ),
- ))
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"{idx + 1}일차 지리적 클러스터 백트래킹 {metric.geo_cluster_backtrack}회 탐지 "
+ f"(같은 시군구 내 지리적으로 분산된 구역 간 왕복)"
+ ),
+ rule="geo_cluster_backtrack",
+ risk="WARNING" if geo_pen == PENALTY_GEO_BT_WARN else "CRITICAL",
+ suggestion=(
+ "같은 행정구역 안에서도 멀리 떨어진 장소를 왕복하고 있습니다. "
+ "인접한 장소끼리 묶어 방문 순서를 재배치하세요."
+ ),
+ )
+ )
if sw_pen > 0:
- deep_dive.append(DeepDiveItem(
- fact=(
- f"{idx + 1}일차 시군구 전환 {metric.sigungu_switches}회 "
- f"(방문: {', '.join(metric.sigungu_codes_visited)})"
- ),
- rule="cluster_dispersion_switches",
- risk="WARNING" if sw_pen == PENALTY_SWITCH_WARN else "CRITICAL",
- suggestion=(
- "하루 안에 너무 많은 시군구를 이동합니다. "
- "같은 지역 내 장소로 묶어주세요."
- ),
- ))
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"{idx + 1}일차 시군구 전환 {metric.sigungu_switches}회 "
+ f"(방문: {', '.join(metric.sigungu_codes_visited)})"
+ ),
+ rule="cluster_dispersion_switches",
+ risk="WARNING" if sw_pen == PENALTY_SWITCH_WARN else "CRITICAL",
+ suggestion=(
+ "하루 안에 너무 많은 시군구를 이동합니다. 같은 지역 내 장소로 묶어주세요."
+ ),
+ )
+ )
if ds_pen > 0:
risk = "CRITICAL" if ds_pen == PENALTY_DIST_CRIT else "WARNING"
- deep_dive.append(DeepDiveItem(
- fact=(
- f"{idx + 1}일차 최대 직선거리 {metric.max_pairwise_km}km "
- f"({len(day.places)}개 장소)"
- ),
- rule="cluster_dispersion_distance",
- risk=risk, # type: ignore[arg-type]
- suggestion=(
- "하루 안에 멀리 떨어진 장소들이 섞여 있습니다. "
- "1일차는 목적지 근처에 집중하고, 다른 지역은 다른 날로 분리하세요."
- ),
- ))
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"{idx + 1}일차 최대 직선거리 {metric.max_pairwise_km}km "
+ f"({len(day.places)}개 장소)"
+ ),
+ rule="cluster_dispersion_distance",
+ risk=risk, # type: ignore[arg-type]
+ suggestion=(
+ "하루 안에 멀리 떨어진 장소들이 섞여 있습니다. "
+ "1일차는 목적지 근처에 집중하고, 다른 지역은 다른 날로 분리하세요."
+ ),
+ )
+ )
return ClusterDispersionReport(
per_day=per_day,
diff --git a/src/scoring/congestion_engine.py b/src/scoring/congestion_engine.py
index a1538f2..a245813 100644
--- a/src/scoring/congestion_engine.py
+++ b/src/scoring/congestion_engine.py
@@ -7,24 +7,24 @@
3. 카테고리 평균 (poi_name에 지역/유형 접두어 기반 클러스터링)
4. 전체 평균
"""
+
from __future__ import annotations
import unicodedata
from dataclasses import dataclass
-from enum import Enum
+from enum import StrEnum
from functools import cached_property
from pathlib import Path
-from typing import TYPE_CHECKING
import pandas as pd
-if TYPE_CHECKING:
- from src.data.seoul_citydata_client import SeoulCityDataClient
+from src.data.models import Settings
+from src.data.seoul_citydata_client import SeoulCityDataClient
_DEFAULT_CSV = Path(__file__).parent.parent.parent / "data" / "congestion_stats.csv"
-class CongestionLevel(str, Enum):
+class CongestionLevel(StrEnum):
LOW = "LOW"
MEDIUM = "MEDIUM"
HIGH = "HIGH"
@@ -35,11 +35,11 @@ class CongestionLevel(str, Enum):
class CongestionResult:
poi_name: str
month: int
- congestion_score: float # 0.0 ~ 1.0
+ congestion_score: float # 0.0 ~ 1.0
level: CongestionLevel
avg_visitors: float
- matched_poi: str # 실제 매칭된 POI명
- fallback_used: str # "exact" | "partial" | "category" | "global"
+ matched_poi: str # 실제 매칭된 POI명
+ fallback_used: str # "exact" | "partial" | "category" | "global"
def _normalize(s: str) -> str:
@@ -75,6 +75,16 @@ def __init__(
self._prefix_len = category_prefix_len
self._seoul: SeoulCityDataClient | None = seoul_client
+ @classmethod
+ def from_settings(cls, settings: Settings | None = None) -> CongestionEngine:
+ settings = settings or Settings()
+ seoul_client = (
+ SeoulCityDataClient(api_key=settings.seoul_data_api_key)
+ if settings.seoul_data_api_key.strip()
+ else None
+ )
+ return cls(seoul_client=seoul_client)
+
@cached_property
def _df(self) -> pd.DataFrame:
if not self._csv_path.exists():
@@ -100,13 +110,12 @@ def _global_avg_by_month(self) -> dict[int, tuple[float, float]]:
def _category_avg_by_month(self) -> dict[str, dict[int, tuple[float, float]]]:
"""prefix → month → (avg_visitors, congestion_score)."""
df = self._df.copy()
- df["prefix"] = df["poi_name"].str[:self._prefix_len]
+ df["prefix"] = df["poi_name"].str[: self._prefix_len]
result: dict[str, dict[int, tuple[float, float]]] = {}
for prefix, group in df.groupby("prefix"):
agg = group.groupby("month")[["avg_visitors", "congestion_score"]].mean()
result[prefix] = {
- int(m): (row["avg_visitors"], row["congestion_score"])
- for m, row in agg.iterrows()
+ int(m): (row["avg_visitors"], row["congestion_score"]) for m, row in agg.iterrows()
}
return result
@@ -150,7 +159,8 @@ def score(self, poi_name: str, month: int) -> CongestionResult:
realtime = self._seoul.get(poi_name)
if realtime is not None:
return CongestionResult(
- poi_name=poi_name, month=month,
+ poi_name=poi_name,
+ month=month,
congestion_score=realtime.score,
level=_score_to_level(realtime.score),
avg_visitors=float((realtime.ppltn_min + realtime.ppltn_max) // 2),
@@ -164,11 +174,13 @@ def score(self, poi_name: str, month: int) -> CongestionResult:
row = self._lookup_exact(norm_name, month)
if row is not None:
return CongestionResult(
- poi_name=poi_name, month=month,
+ poi_name=poi_name,
+ month=month,
congestion_score=float(row["congestion_score"]),
level=_score_to_level(float(row["congestion_score"])),
avg_visitors=float(row["avg_visitors"]),
- matched_poi=row["poi_name"], fallback_used="exact",
+ matched_poi=row["poi_name"],
+ fallback_used="exact",
)
# 2. Partial match
@@ -176,42 +188,46 @@ def score(self, poi_name: str, month: int) -> CongestionResult:
if partial is not None:
row, matched = partial
return CongestionResult(
- poi_name=poi_name, month=month,
+ poi_name=poi_name,
+ month=month,
congestion_score=float(row["congestion_score"]),
level=_score_to_level(float(row["congestion_score"])),
avg_visitors=float(row["avg_visitors"]),
- matched_poi=matched, fallback_used="partial",
+ matched_poi=matched,
+ fallback_used="partial",
)
# 3. Category average (prefix-based)
- prefix = norm_name[:self._prefix_len]
+ prefix = norm_name[: self._prefix_len]
cat_data = self._category_avg_by_month.get(prefix, {})
if month in cat_data:
avg_v, score = cat_data[month]
return CongestionResult(
- poi_name=poi_name, month=month,
+ poi_name=poi_name,
+ month=month,
congestion_score=round(score, 4),
level=_score_to_level(score),
avg_visitors=round(avg_v, 1),
- matched_poi=f"[카테고리:{prefix}*]", fallback_used="category",
+ matched_poi=f"[카테고리:{prefix}*]",
+ fallback_used="category",
)
# 4. Global average
avg_v, score = self._global_avg_by_month.get(month, (0.0, 0.5))
return CongestionResult(
- poi_name=poi_name, month=month,
+ poi_name=poi_name,
+ month=month,
congestion_score=round(score, 4),
level=_score_to_level(score),
avg_visitors=round(avg_v, 1),
- matched_poi="[전체평균]", fallback_used="global",
+ matched_poi="[전체평균]",
+ fallback_used="global",
)
def is_crowded(self, poi_name: str, month: int, threshold: float = 0.7) -> bool:
"""congestion_score >= threshold 이면 True."""
return self.score(poi_name, month).congestion_score >= threshold
- def score_itinerary(
- self, pois: list[str], month: int
- ) -> list[CongestionResult]:
+ def score_itinerary(self, pois: list[str], month: int) -> list[CongestionResult]:
"""여행 일정의 모든 POI 혼잡도를 일괄 반환한다."""
return [self.score(poi, month) for poi in pois]
diff --git a/src/scoring/reward_engine.py b/src/scoring/reward_engine.py
index 57ac827..eb99530 100644
--- a/src/scoring/reward_engine.py
+++ b/src/scoring/reward_engine.py
@@ -10,6 +10,7 @@
- purpose_fit ≥ 0.80 → 여행 테마 일치
- n_warnings == 0 → 경고 없음
"""
+
from __future__ import annotations
from src.data.models import Scores
@@ -55,9 +56,7 @@ def generate_rewards(
)
if scores.purpose_fit >= PURPOSE_FIT_EXCELLENT:
- messages.append(
- "선택하신 장소들이 여행 목적에 잘 맞습니다. 테마에 집중된 알찬 일정이에요."
- )
+ messages.append("선택하신 장소들이 여행 목적에 잘 맞습니다. 테마에 집중된 알찬 일정이에요.")
if n_warnings == 0:
messages.append(
diff --git a/src/scoring/theme_alignment.py b/src/scoring/theme_alignment.py
index ecb0b31..5785286 100644
--- a/src/scoring/theme_alignment.py
+++ b/src/scoring/theme_alignment.py
@@ -10,29 +10,30 @@
- Prompt Caching: system 프롬프트는 cache_control: ephemeral 적용
- Timeout: 10초, 실패 시 정보성 DeepDive
"""
+
from __future__ import annotations
import hashlib
import json
-import os
from dataclasses import dataclass, field
from typing import Any
-from src.data.models import DeepDiveItem
+from src.data.models import DeepDiveItem, Settings
from src.data.theme_taxonomy import TRAVEL_STYLE_DESCRIPTIONS, UserPreferences
# Anthropic SDK는 선택적 의존성
try:
import anthropic
+
_ANTHROPIC_AVAILABLE = True
except ImportError:
_ANTHROPIC_AVAILABLE = False
# ── 패널티 임계값 ─────────────────────────────────────────────────────
-WARN_THRESHOLD: float = 0.8 # 0.6 ≤ score < 0.8 → -5
-RISK_THRESHOLD: float = 0.6 # 0.4 ≤ score < 0.6 → -10
-CRIT_THRESHOLD: float = 0.4 # score < 0.4 → -20
+WARN_THRESHOLD: float = 0.8 # 0.6 ≤ score < 0.8 → -5
+RISK_THRESHOLD: float = 0.6 # 0.4 ≤ score < 0.6 → -10
+CRIT_THRESHOLD: float = 0.4 # score < 0.4 → -20
PENALTY_WARN: int = 5
PENALTY_RISK: int = 10
@@ -67,8 +68,9 @@
@dataclass
class POIWithCategory:
"""LLM에게 전달할 POI 정보 (카테고리 명 포함)."""
+
name: str
- category_name: str = "" # 예: "자연관광지/산", "음식점/카페"
+ category_name: str = "" # 예: "자연관광지/산", "음식점/카페"
visit_order: int = 0
stay_minutes: int = 0
@@ -76,15 +78,16 @@ class POIWithCategory:
@dataclass(frozen=True)
class ThemeJudgment:
"""LLM 평가 결과."""
- score: float # 0.0 ~ 1.0
+
+ score: float # 0.0 ~ 1.0
reasoning: str
mismatched_places: list[str] = field(default_factory=list)
- api_used: bool = True # False = LLM 호출 없이 폴백
+ api_used: bool = True # False = LLM 호출 없이 폴백
@dataclass(frozen=True)
class ThemeAlignmentReport:
- judgment: ThemeJudgment | None # None = LLM 미호출
+ judgment: ThemeJudgment | None # None = LLM 미호출
penalty: int
deep_dive: list[DeepDiveItem]
@@ -151,7 +154,7 @@ def _parse_llm_response(raw_text: str) -> ThemeJudgment:
data = json.loads(text)
score = float(data.get("score", 0.5))
- score = max(0.0, min(1.0, score)) # clamp
+ score = max(0.0, min(1.0, score)) # clamp
return ThemeJudgment(
score=score,
reasoning=str(data.get("reasoning", "")),
@@ -174,12 +177,12 @@ def __init__(
model: str = DEFAULT_MODEL,
timeout_sec: float = DEFAULT_TIMEOUT_SEC,
max_tokens: int = DEFAULT_MAX_TOKENS,
- client: Any = None, # 테스트에서 주입 가능
+ client: Any = None, # 테스트에서 주입 가능
) -> None:
self._model = model
self._timeout = timeout_sec
self._max_tokens = max_tokens
- self._api_key = api_key or os.environ.get("ANTHROPIC_API_KEY", "")
+ self._api_key = Settings().anthropic_api_key if api_key is None else api_key
self._client = client
if self._client is None and _ANTHROPIC_AVAILABLE and self._api_key:
self._client = anthropic.Anthropic(api_key=self._api_key)
@@ -196,19 +199,18 @@ def evaluate(
"""테마 일치도 평가 + 패널티 산출."""
# ── LLM 사용 불가 케이스: 정보성 DeepDive만 ──
if not self.is_available():
- reason = (
- "ANTHROPIC_API_KEY 미설정" if not self._api_key
- else "anthropic SDK 미설치"
- )
+ reason = "ANTHROPIC_API_KEY 미설정" if not self._api_key else "anthropic SDK 미설치"
return ThemeAlignmentReport(
judgment=None,
penalty=0,
- deep_dive=[DeepDiveItem(
- fact=f"테마 일치성 평가 미수행 — {reason}",
- rule="theme_alignment_skipped",
- risk="OK",
- suggestion="ANTHROPIC_API_KEY 환경변수 설정 후 재실행하세요.",
- )],
+ deep_dive=[
+ DeepDiveItem(
+ fact=f"테마 일치성 평가 미수행 — {reason}",
+ rule="theme_alignment_skipped",
+ risk="OK",
+ suggestion="ANTHROPIC_API_KEY 환경변수 설정 후 재실행하세요.",
+ )
+ ],
)
# ── 캐시 조회 ──
@@ -223,12 +225,14 @@ def evaluate(
return ThemeAlignmentReport(
judgment=None,
penalty=0,
- deep_dive=[DeepDiveItem(
- fact=f"LLM 호출 실패 — {type(e).__name__}: {str(e)[:100]}",
- rule="theme_alignment_error",
- risk="OK",
- suggestion="네트워크/API 키 확인 후 재시도하세요.",
- )],
+ deep_dive=[
+ DeepDiveItem(
+ fact=f"LLM 호출 실패 — {type(e).__name__}: {str(e)[:100]}",
+ rule="theme_alignment_error",
+ risk="OK",
+ suggestion="네트워크/API 키 확인 후 재시도하세요.",
+ )
+ ],
)
# ── 패널티 + DeepDive 생성 ──
@@ -237,20 +241,23 @@ def evaluate(
if penalty > 0:
mismatched_str = (
f" 어긋난 장소: {', '.join(judgment.mismatched_places)}"
- if judgment.mismatched_places else ""
+ if judgment.mismatched_places
+ else ""
+ )
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"테마 일치도 {judgment.score:.2f}/1.0 — "
+ f"{judgment.reasoning}{mismatched_str}"
+ ),
+ rule="theme_alignment",
+ risk=risk, # type: ignore[arg-type]
+ suggestion=(
+ "선택하신 테마에 맞지 않는 장소들을 더 적합한 곳으로 교체하거나, "
+ "테마를 다시 선택해 보세요."
+ ),
+ )
)
- deep_dive.append(DeepDiveItem(
- fact=(
- f"테마 일치도 {judgment.score:.2f}/1.0 — "
- f"{judgment.reasoning}{mismatched_str}"
- ),
- rule="theme_alignment",
- risk=risk, # type: ignore[arg-type]
- suggestion=(
- "선택하신 테마에 맞지 않는 장소들을 더 적합한 곳으로 교체하거나, "
- "테마를 다시 선택해 보세요."
- ),
- ))
return ThemeAlignmentReport(
judgment=judgment,
@@ -271,11 +278,13 @@ def _call_llm(
model=self._model,
max_tokens=self._max_tokens,
timeout=self._timeout,
- system=[{
- "type": "text",
- "text": SYSTEM_PROMPT,
- "cache_control": {"type": "ephemeral"},
- }],
+ system=[
+ {
+ "type": "text",
+ "text": SYSTEM_PROMPT,
+ "cache_control": {"type": "ephemeral"},
+ }
+ ],
messages=[{"role": "user", "content": user_prompt}],
)
diff --git a/src/scoring/travel_ratio.py b/src/scoring/travel_ratio.py
index 4d0ef6f..c88d4b9 100644
--- a/src/scoring/travel_ratio.py
+++ b/src/scoring/travel_ratio.py
@@ -5,6 +5,7 @@
기존 `phases/0-setup/analyze.py`의 정의 유지.
임계값은 구석구석 50개 / 트리플 38개 실측 P75/P90 기반.
"""
+
from __future__ import annotations
from dataclasses import dataclass
@@ -12,7 +13,6 @@
from src.data.models import DeepDiveItem, VRPTWDay, VRPTWPlace
from src.validation.vrptw_engine import HaversineMatrix, TimeMatrix
-
# ── 임계값 (구석구석 P75=0.20, P90=0.50 기반) ─────────────────────────
WARN_THRESHOLD: float = 0.20
RISK_THRESHOLD: float = 0.40
@@ -27,6 +27,7 @@
@dataclass(frozen=True)
class DayRatioMetric:
"""일자별 비율 측정 결과."""
+
day_index: int
travel_sec: int
dwell_sec: int
@@ -36,9 +37,10 @@ class DayRatioMetric:
@dataclass(frozen=True)
class TravelRatioReport:
"""전체 평가 리포트."""
+
per_day: list[DayRatioMetric]
- overall_ratio: float # 전체 일정 합산 기준
- total_penalty: int # 일자별 패널티 합산
+ overall_ratio: float # 전체 일정 합산 기준
+ total_penalty: int # 일자별 패널티 합산
deep_dive: list[DeepDiveItem]
@@ -102,18 +104,20 @@ def evaluate_travel_ratio(
total_penalty += penalty
travel_min = metric.travel_sec // 60
dwell_min = metric.dwell_sec // 60
- deep_dive.append(DeepDiveItem(
- fact=(
- f"{idx + 1}일차 이동 비율 {metric.travel_ratio:.1%} "
- f"(이동 {travel_min}분 / 관광 {dwell_min}분)"
- ),
- rule="travel_ratio",
- risk=risk, # type: ignore[arg-type]
- suggestion=(
- "이동 시간이 관광 시간 대비 너무 큽니다. "
- "더 가까운 장소로 변경하거나 일정을 단순화하세요."
- ),
- ))
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"{idx + 1}일차 이동 비율 {metric.travel_ratio:.1%} "
+ f"(이동 {travel_min}분 / 관광 {dwell_min}분)"
+ ),
+ rule="travel_ratio",
+ risk=risk, # type: ignore[arg-type]
+ suggestion=(
+ "이동 시간이 관광 시간 대비 너무 큽니다. "
+ "더 가까운 장소로 변경하거나 일정을 단순화하세요."
+ ),
+ )
+ )
overall_total = total_travel + total_dwell
overall_ratio = total_travel / overall_total if overall_total > 0 else 0.0
diff --git a/src/utils/geo.py b/src/utils/geo.py
index bb16d0b..dd1297a 100644
--- a/src/utils/geo.py
+++ b/src/utils/geo.py
@@ -1,4 +1,5 @@
"""공유 지리 계산 유틸리티 — Haversine, NN 휴리스틱, 이동시간 조회."""
+
from __future__ import annotations
import math
@@ -27,9 +28,7 @@ def build_dist_cache(pois: list) -> dict[tuple[int, int], float]:
for i in range(n):
for j in range(n):
if i != j:
- cache[(i, j)] = haversine_km(
- pois[i].lat, pois[i].lng, pois[j].lat, pois[j].lng
- )
+ cache[(i, j)] = haversine_km(pois[i].lat, pois[i].lng, pois[j].lat, pois[j].lng)
return cache
@@ -55,8 +54,10 @@ def nn_heuristic_km(
dist_cache[(current, j)]
if dist_cache is not None
else haversine_km(
- pois[current].lat, pois[current].lng,
- pois[j].lat, pois[j].lng,
+ pois[current].lat,
+ pois[current].lng,
+ pois[j].lat,
+ pois[j].lng,
)
)
if d < best_d:
@@ -81,6 +82,9 @@ def get_travel_min(
dist_cache 를 넘기면 폴백 시 재계산 없이 조회한다.
"""
+ if matrix is not None and hasattr(matrix, "get_travel_min"):
+ return float(matrix.get_travel_min(origin, dest))
+
entry = (matrix.get(i) or {}).get(j)
if entry and "travel_min" in entry:
return float(entry["travel_min"])
diff --git a/src/validation/alternatives.py b/src/validation/alternatives.py
index 0e2670c..f63931e 100644
--- a/src/validation/alternatives.py
+++ b/src/validation/alternatives.py
@@ -18,15 +18,16 @@
)
# → {"경복궁": [AlternativePOI(name="창덕궁", ...), ...]}
"""
+
from __future__ import annotations
import math
-from typing import Sequence
+from collections.abc import Sequence
-from src.data.models import AlternativePOI, HardFail, POI
+from src.data.models import POI, AlternativePOI, HardFail
_EARTH_R = 6371.0
-_MAX_SEARCH_KM = 10.0 # 기본 탐색 반경
+_MAX_SEARCH_KM = 10.0 # 기본 탐색 반경
def _haversine_km(lat1: float, lng1: float, lat2: float, lng2: float) -> float:
diff --git a/src/validation/hard_fail.py b/src/validation/hard_fail.py
index a314b7b..8b9effb 100644
--- a/src/validation/hard_fail.py
+++ b/src/validation/hard_fail.py
@@ -1,15 +1,16 @@
"""Hard Fail 탐지기 (운영시간 충돌·이동 불가·일정 시간 초과)."""
+
from __future__ import annotations
-from src.data.models import HardFail, ItineraryPlan, POI
+from src.data.models import POI, HardFail, ItineraryPlan
from src.utils.geo import build_dist_cache, get_travel_min
DEFAULT_START_MINUTES: int = 9 * 60 # 09:00
HARD_FAIL_TYPES = {
"OPERATING_HOURS_CONFLICT": "도착 예상 시간이 POI 운영시간 외",
- "TRAVEL_TIME_IMPOSSIBLE": "이동시간이 이용 가능한 시간 창을 초과",
- "SCHEDULE_INFEASIBLE": "전체 일정이 시간 내 수행 불가능",
+ "TRAVEL_TIME_IMPOSSIBLE": "이동시간이 이용 가능한 시간 창을 초과",
+ "SCHEDULE_INFEASIBLE": "전체 일정이 시간 내 수행 불가능",
}
@@ -26,19 +27,26 @@ def detect(
plan: ItineraryPlan,
pois: list[POI],
matrix: dict,
- start_minutes: int = DEFAULT_START_MINUTES,
+ start_minutes: int | None = None,
origin_poi: POI | None = None,
day_index: int | None = None,
) -> list[HardFail]:
"""Hard Fail 목록 반환. 없으면 빈 리스트."""
+ if start_minutes is None:
+ start_minutes = self._time_to_min(plan.start_time)
+
# origin_poi 가 있으면 pois 앞에 가상 출발 인덱스(-1)로 붙여 처리
effective_pois = pois if origin_poi is None else [origin_poi] + list(pois)
offset = 0 if origin_poi is None else 1 # 실제 POI 인덱스 오프셋
dist_cache = build_dist_cache(effective_pois)
fails: list[HardFail] = []
- fails.extend(self._check_operating_hours(effective_pois, matrix, start_minutes, offset, dist_cache))
- fails.extend(self._check_travel_impossible(effective_pois, matrix, start_minutes, offset, dist_cache))
+ fails.extend(
+ self._check_operating_hours(effective_pois, matrix, start_minutes, offset, dist_cache)
+ )
+ fails.extend(
+ self._check_travel_impossible(effective_pois, matrix, start_minutes, offset, dist_cache)
+ )
fails.extend(self._check_schedule_infeasible(effective_pois, matrix, offset, dist_cache))
if day_index is not None:
for f in fails:
@@ -78,31 +86,53 @@ def _check_operating_hours(
est = getattr(poi, "hours_estimated", False)
note = " (추정 영업시간 기준 — 방문 전 확인을 권장합니다)" if est else ""
if arrive < open_min:
- fails.append(HardFail(
- fail_type="OPERATING_HOURS_CONFLICT",
- message=(
- f"'{poi.name}' 도착 예정 {self._min_to_time(arrive)}, "
- f"운영 시작 {poi.open_start} — 아직 문을 열지 않았습니다." + note
- ),
- evidence=f"도착 {self._min_to_time(arrive)} < 운영시작 {poi.open_start}",
- confidence="Medium",
- poi_name=poi.name,
- estimated=est,
- ))
+ fails.append(
+ HardFail(
+ fail_type="OPERATING_HOURS_CONFLICT",
+ message=(
+ f"'{poi.name}' 도착 예정 {self._min_to_time(arrive)}, "
+ f"운영 시작 {poi.open_start} — 아직 문을 열지 않았습니다." + note
+ ),
+ evidence=f"도착 {self._min_to_time(arrive)} < 운영시작 {poi.open_start}",
+ confidence="Medium",
+ poi_name=poi.name,
+ estimated=est,
+ )
+ )
elif arrive > close_min:
- fails.append(HardFail(
+ fails.append(
+ HardFail(
+ fail_type="OPERATING_HOURS_CONFLICT",
+ message=(
+ f"'{poi.name}' 도착 예정 {self._min_to_time(arrive)}, "
+ f"운영 종료 {poi.open_end} — 이미 문을 닫았습니다." + note
+ ),
+ evidence=f"도착 {self._min_to_time(arrive)} > 운영종료 {poi.open_end}",
+ confidence="Medium",
+ poi_name=poi.name,
+ estimated=est,
+ )
+ )
+
+ effective_arrive = max(arrive, open_min)
+ if not is_fallback and effective_arrive + poi.duration_min > close_min:
+ fails.append(
+ HardFail(
fail_type="OPERATING_HOURS_CONFLICT",
message=(
- f"'{poi.name}' 도착 예정 {self._min_to_time(arrive)}, "
- f"운영 종료 {poi.open_end} — 이미 문을 닫았습니다." + note
+ f"'{poi.name}' 방문 종료 예정 "
+ f"{self._min_to_time(effective_arrive + poi.duration_min)}, "
+ f"운영 종료 {poi.open_end} 이후까지 체류합니다." + note
+ ),
+ evidence=(
+ f"방문 종료 {self._min_to_time(effective_arrive + poi.duration_min)} "
+ f"> 운영종료 {poi.open_end}"
),
- evidence=f"도착 {self._min_to_time(arrive)} > 운영종료 {poi.open_end}",
confidence="Medium",
poi_name=poi.name,
estimated=est,
- ))
-
- effective_arrive = max(arrive, open_min)
+ )
+ )
current_time = effective_arrive + poi.duration_min
return fails
@@ -134,19 +164,21 @@ def _check_travel_impossible(
available_window = close_min - current_time
if not is_fallback and travel_min > available_window:
- fails.append(HardFail(
- fail_type="TRAVEL_TIME_IMPOSSIBLE",
- message=(
- f"'{prev.name}'→'{poi.name}' 이동 시간 {travel_min:.0f}분이 "
- f"가용 시간 창 {available_window:.0f}분을 초과합니다."
- ),
- evidence=(
- f"이동 {travel_min:.0f}분 > 가용 창 {available_window:.0f}분 "
- f"(출발 {self._min_to_time(current_time)}, '{poi.name}' 종료 {poi.open_end})"
- ),
- confidence="High",
- poi_name=poi.name,
- ))
+ fails.append(
+ HardFail(
+ fail_type="TRAVEL_TIME_IMPOSSIBLE",
+ message=(
+ f"'{prev.name}'→'{poi.name}' 이동 시간 {travel_min:.0f}분이 "
+ f"가용 시간 창 {available_window:.0f}분을 초과합니다."
+ ),
+ evidence=(
+ f"이동 {travel_min:.0f}분 > 가용 창 {available_window:.0f}분 "
+ f"(출발 {self._min_to_time(current_time)}, '{poi.name}' 종료 {poi.open_end})"
+ ),
+ confidence="High",
+ poi_name=poi.name,
+ )
+ )
arrive = current_time + travel_min
effective_arrive = max(arrive, open_min)
@@ -170,18 +202,20 @@ def _check_schedule_infeasible(
total_min = total_dwell + total_travel_min
if total_min > 24 * 60:
- return [HardFail(
- fail_type="SCHEDULE_INFEASIBLE",
- message=(
- f"총 일정 소요 시간 {total_min:.0f}분 ({total_min / 60:.1f}시간)이 "
- f"24시간을 초과합니다."
- ),
- evidence=(
- f"체류 {total_dwell}분 + 이동 {total_travel_min:.0f}분 "
- f"= {total_min:.0f}분 > 1440분"
- ),
- confidence="High",
- )]
+ return [
+ HardFail(
+ fail_type="SCHEDULE_INFEASIBLE",
+ message=(
+ f"총 일정 소요 시간 {total_min:.0f}분 ({total_min / 60:.1f}시간)이 "
+ f"24시간을 초과합니다."
+ ),
+ evidence=(
+ f"체류 {total_dwell}분 + 이동 {total_travel_min:.0f}분 "
+ f"= {total_min:.0f}분 > 1440분"
+ ),
+ confidence="High",
+ )
+ ]
return []
@staticmethod
@@ -191,5 +225,7 @@ def _time_to_min(hhmm: str) -> int:
@staticmethod
def _min_to_time(minutes: float) -> str:
- m = int(minutes) % 1440 # 24시간 시계로 정규화 (누적 이동시간이 하루를 넘어도 유효한 시각으로 표시)
+ m = (
+ int(minutes) % 1440
+ ) # 24시간 시계로 정규화 (누적 이동시간이 하루를 넘어도 유효한 시각으로 표시)
return f"{m // 60:02d}:{m % 60:02d}"
diff --git a/src/validation/kakao_matrix.py b/src/validation/kakao_matrix.py
index d708c26..3a3b42c 100644
--- a/src/validation/kakao_matrix.py
+++ b/src/validation/kakao_matrix.py
@@ -21,25 +21,24 @@
6. async aprefetch_matrix: httpx.AsyncClient로 N×N 쌍 비동기 사전 로드
(get_travel_time은 동기 유지 — VRPTWEngine/OR-Tools 호환)
"""
+
from __future__ import annotations
import asyncio
import json
-import os
import time
from pathlib import Path
from typing import Any
import httpx
-from src.data.models import VRPTWPlace
+from src.data.models import Settings, VRPTWPlace
from src.validation.vrptw_engine import HaversineMatrix, TimeMatrix
-
KAKAO_DIRECTIONS_URL = "https://apis-navi.kakaomobility.com/v1/directions"
DEFAULT_TIMEOUT_SEC: float = 5.0
-DEFAULT_SLEEP_BETWEEN: float = 0.05 # 초당 ~20회
+DEFAULT_SLEEP_BETWEEN: float = 0.05 # 초당 ~20회
DEFAULT_MAX_RETRIES: int = 3
DEFAULT_RETRY_BACKOFF: float = 2.0
@@ -80,7 +79,10 @@ def __init__(
self._fallback = HaversineMatrix()
self._quota_exhausted = False
self._stats: dict[str, int] = {
- "cache_hit": 0, "api_success": 0, "api_fail": 0, "fallback": 0,
+ "cache_hit": 0,
+ "api_success": 0,
+ "api_fail": 0,
+ "fallback": 0,
}
self._dirty_count = 0
@@ -91,32 +93,12 @@ def from_env(
cache_path: str | Path | None = None,
env_path: str | Path | None = None,
**kwargs: Any,
- ) -> "KakaoMobilityMatrix":
+ ) -> KakaoMobilityMatrix:
"""`.env`에서 KAKAO_MOBILITY_KEY (없으면 KAKAO_REST_API_KEY) 로드."""
- if env_path:
- cls._load_dotenv(Path(env_path))
- else:
- project_root = Path(__file__).resolve().parents[2]
- env_default = project_root / ".env"
- if env_default.exists():
- cls._load_dotenv(env_default)
-
- key = (
- os.environ.get("KAKAO_MOBILITY_KEY", "")
- or os.environ.get("KAKAO_REST_API_KEY", "")
- )
+ settings = Settings(_env_file=env_path) if env_path else Settings()
+ key = settings.kakao_mobility_key or settings.kakao_rest_api_key
return cls(api_key=key, cache_path=cache_path, **kwargs)
- @staticmethod
- def _load_dotenv(env_path: Path) -> None:
- if not env_path.exists():
- return
- for line in env_path.read_text(encoding="utf-8").splitlines():
- line = line.strip()
- if line and not line.startswith("#") and "=" in line:
- k, _, v = line.partition("=")
- os.environ.setdefault(k.strip(), v.strip())
-
# ── TimeMatrix 인터페이스 (동기) ──────────────────────────────────────
def get_travel_time(self, origin: VRPTWPlace, destination: VRPTWPlace) -> int:
"""캐시 조회 + Haversine 폴백. API 직접 호출 없음."""
@@ -147,10 +129,7 @@ async def aprefetch_matrix(
항상 캐시 히트되어 레이턴시 없이 동작한다.
"""
pairs = [
- (places[i], places[j])
- for i in range(len(places))
- for j in range(len(places))
- if i != j
+ (places[i], places[j]) for i in range(len(places)) for j in range(len(places)) if i != j
]
sem = asyncio.Semaphore(concurrency)
@@ -174,22 +153,18 @@ async def fetch_one(origin: VRPTWPlace, dest: VRPTWPlace) -> None:
self.save_cache()
# ── 비동기 API 호출 ──────────────────────────────────────────────────
- async def _acall_kakao(
- self, origin: VRPTWPlace, destination: VRPTWPlace
- ) -> int | None:
+ async def _acall_kakao(self, origin: VRPTWPlace, destination: VRPTWPlace) -> int | None:
"""카카오 모빌리티 비동기 호출 (httpx.AsyncClient)."""
headers = {"Authorization": f"KakaoAK {self._api_key}"}
params = {
- "origin": f"{origin.lng},{origin.lat}",
+ "origin": f"{origin.lng},{origin.lat}",
"destination": f"{destination.lng},{destination.lat}",
}
async with httpx.AsyncClient(timeout=self._timeout) as client:
for attempt in range(1, self._max_retries + 1):
try:
- r = await client.get(
- KAKAO_DIRECTIONS_URL, headers=headers, params=params
- )
+ r = await client.get(KAKAO_DIRECTIONS_URL, headers=headers, params=params)
if r.status_code == 200:
return self._parse_duration(r.json())
if r.status_code == 429:
@@ -198,10 +173,10 @@ async def _acall_kakao(
return None
if r.status_code in (401, 403):
raise RuntimeError(f"인증 오류 {r.status_code}")
- await asyncio.sleep(DEFAULT_RETRY_BACKOFF ** attempt)
+ await asyncio.sleep(DEFAULT_RETRY_BACKOFF**attempt)
except httpx.RequestError as e:
if attempt < self._max_retries:
- await asyncio.sleep(DEFAULT_RETRY_BACKOFF ** attempt)
+ await asyncio.sleep(DEFAULT_RETRY_BACKOFF**attempt)
else:
print(f" [kakao-mobility] 실패: {e}")
@@ -209,9 +184,7 @@ async def _acall_kakao(
return None
# ── 동기 API 호출 (캐시 워밍업 스크립트용) ──────────────────────────
- def _call_kakao_sync(
- self, origin: VRPTWPlace, destination: VRPTWPlace
- ) -> int | None:
+ def _call_kakao_sync(self, origin: VRPTWPlace, destination: VRPTWPlace) -> int | None:
"""동기 API 호출 + 캐시 저장 + 통계 업데이트 (httpx.Client).
캐시에 이미 있으면 API 호출 없이 캐시 값 반환.
@@ -230,7 +203,7 @@ def _call_kakao_sync(
headers = {"Authorization": f"KakaoAK {self._api_key}"}
params = {
- "origin": f"{origin.lng},{origin.lat}",
+ "origin": f"{origin.lng},{origin.lat}",
"destination": f"{destination.lng},{destination.lat}",
}
@@ -251,10 +224,10 @@ def _call_kakao_sync(
return None
if r.status_code in (401, 403):
raise RuntimeError(f"인증 오류 {r.status_code}")
- time.sleep(DEFAULT_RETRY_BACKOFF ** attempt)
+ time.sleep(DEFAULT_RETRY_BACKOFF**attempt)
except httpx.RequestError as e:
if attempt < self._max_retries:
- time.sleep(DEFAULT_RETRY_BACKOFF ** attempt)
+ time.sleep(DEFAULT_RETRY_BACKOFF**attempt)
else:
print(f" [kakao-mobility] 실패: {e}")
@@ -276,10 +249,7 @@ def _parse_duration(data: dict) -> int | None:
# ── 캐시 입출력 ──────────────────────────────────────────────────────
def _make_key(self, origin: VRPTWPlace, destination: VRPTWPlace) -> str:
- return (
- f"{origin.lng:.4f},{origin.lat:.4f}"
- f"|{destination.lng:.4f},{destination.lat:.4f}"
- )
+ return f"{origin.lng:.4f},{origin.lat:.4f}|{destination.lng:.4f},{destination.lat:.4f}"
def _load_cache(self) -> dict[str, int]:
if not self._cache_path or not self._cache_path.exists():
@@ -300,9 +270,7 @@ def save_cache(self) -> None:
if not self._cache_path:
return
self._cache_path.parent.mkdir(parents=True, exist_ok=True)
- self._cache_path.write_text(
- json.dumps(self._cache, ensure_ascii=False), encoding="utf-8"
- )
+ self._cache_path.write_text(json.dumps(self._cache, ensure_ascii=False), encoding="utf-8")
self._dirty_count = 0
# ── 진단 ─────────────────────────────────────────────────────────────
diff --git a/src/validation/scoring.py b/src/validation/scoring.py
index a6ea3bc..a5eda1c 100644
--- a/src/validation/scoring.py
+++ b/src/validation/scoring.py
@@ -1,16 +1,17 @@
"""5개 지표 기반 최종 점수 계산기."""
+
from __future__ import annotations
-from src.data.models import HardFail, ItineraryPlan, POI, Scores
+from src.data.models import POI, HardFail, ItineraryPlan, Scores
from src.data.party_config import get_party_profile
from src.utils.geo import build_dist_cache, get_travel_min, nn_heuristic_km
from src.validation.warning import INTENT_VECTORS, _cosine_distance
WEIGHTS = {
- "efficiency": 0.30,
- "feasibility": 0.25,
- "purpose_fit": 0.20,
- "flow": 0.15,
+ "efficiency": 0.30,
+ "feasibility": 0.25,
+ "purpose_fit": 0.20,
+ "flow": 0.15,
"area_intensity": 0.10,
}
@@ -34,10 +35,10 @@ def compute(
"""
dist_cache = build_dist_cache(pois)
- efficiency = self._calc_efficiency(pois, dist_cache)
- feasibility = self._calc_feasibility(plan, pois, matrix, hard_fails, dist_cache)
- purpose_fit = self._calc_purpose_fit(plan, pois)
- flow = self._calc_flow(pois, dist_cache)
+ efficiency = self._calc_efficiency(pois, dist_cache)
+ feasibility = self._calc_feasibility(plan, pois, matrix, hard_fails, dist_cache)
+ purpose_fit = self._calc_purpose_fit(plan, pois)
+ flow = self._calc_flow(pois, dist_cache)
area_intensity = self._calc_area_intensity(pois)
scores = Scores(
@@ -147,9 +148,7 @@ def _calc_flow(
actual_km = sum(dist_cache.get((i, i + 1), 0.0) for i in range(n - 1))
nn_km = nn_heuristic_km(pois, dist_cache)
- backtrack_ratio = (
- max(0.0, (actual_km - nn_km) / actual_km) if actual_km > 0 else 0.0
- )
+ backtrack_ratio = max(0.0, (actual_km - nn_km) / actual_km) if actual_km > 0 else 0.0
seen: dict[str, bool] = {}
prev_cat: str | None = None
diff --git a/src/validation/vrptw_engine.py b/src/validation/vrptw_engine.py
index a3737a7..ca59a3b 100644
--- a/src/validation/vrptw_engine.py
+++ b/src/validation/vrptw_engine.py
@@ -6,6 +6,7 @@
TimeMatrix interface is swappable — replace CachedRouteMatrix with a Kakao
Mobility implementation without touching solver code.
"""
+
from __future__ import annotations
import json
@@ -13,7 +14,6 @@
from abc import ABC, abstractmethod
from dataclasses import dataclass, field
from pathlib import Path
-from typing import TYPE_CHECKING
from src.data.models import (
DayRouteComparison,
@@ -24,18 +24,24 @@
VRPTWResult,
)
+
+def _time_to_minutes(value: str) -> int:
+ hour, minute = map(int, value.split(":"))
+ return hour * 60 + minute
+
+
# ---------------------------------------------------------------------------
# Tunable thresholds
# ---------------------------------------------------------------------------
-EFFICIENCY_GAP_THRESHOLD: float = 0.20 # 20%: efficiency gap that triggers "low efficiency"
-FATIGUE_HOURS_LIMIT: int = 12 # hours: daily schedule exceeding this incurs penalty
-FATIGUE_PENALTY_PER_HOUR: int = 10 # points deducted per hour over limit
-SAFETY_MARGIN_MINUTES: int = 60 # minutes: arrival within this of close → CRITICAL
-PASS_THRESHOLD: int = 60 # risk_score >= this → passed
+EFFICIENCY_GAP_THRESHOLD: float = 0.20 # 20%: efficiency gap that triggers "low efficiency"
+FATIGUE_HOURS_LIMIT: int = 12 # hours: daily schedule exceeding this incurs penalty
+FATIGUE_PENALTY_PER_HOUR: int = 10 # points deducted per hour over limit
+SAFETY_MARGIN_MINUTES: int = 60 # minutes: arrival within this of close → CRITICAL
+PASS_THRESHOLD: int = 60 # risk_score >= this → passed
# Day-start time assumption when no depot open time is specified
-DEFAULT_START_MINUTES: int = 9 * 60 # 09:00
+DEFAULT_START_MINUTES: int = 9 * 60 # 09:00
# ---------------------------------------------------------------------------
# OR-Tools import (graceful degradation)
@@ -43,6 +49,7 @@
try:
from ortools.constraint_solver import pywrapcp, routing_enums_pb2
+
_ORTOOLS_AVAILABLE = True
except Exception:
_ORTOOLS_AVAILABLE = False
@@ -52,6 +59,7 @@
# TimeMatrix interface
# ---------------------------------------------------------------------------
+
class TimeMatrix(ABC):
"""Abstract travel-time provider. Implementations are interchangeable."""
@@ -72,8 +80,8 @@ class HaversineMatrix(TimeMatrix):
# (거리 상한 m, 유효 속도 m/s)
_BANDS: tuple = (
- (5_000, 12_000 / 3600), # 도심 <5km
- (50_000, 22_000 / 3600), # 중거리 5~50km
+ (5_000, 12_000 / 3600), # 도심 <5km
+ (50_000, 22_000 / 3600), # 중거리 5~50km
(float("inf"), 80_000 / 3600), # 장거리 >50km
)
@@ -109,7 +117,7 @@ def __init__(self, cache: dict[str, int]) -> None:
self._fallback = HaversineMatrix()
@classmethod
- def from_file(cls, path: str | Path) -> "CachedRouteMatrix":
+ def from_file(cls, path: str | Path) -> CachedRouteMatrix:
with open(path, encoding="utf-8") as f:
data: dict[str, int] = json.load(f)
return cls(data)
@@ -126,7 +134,6 @@ def get_travel_time(self, origin: VRPTWPlace, destination: VRPTWPlace) -> int:
return self._fallback.get_travel_time(origin, destination)
-
def _haversine_m(lat1: float, lng1: float, lat2: float, lng2: float) -> float:
R = 6_371_000.0
phi1, phi2 = math.radians(lat1), math.radians(lat2)
@@ -140,9 +147,11 @@ def _haversine_m(lat1: float, lng1: float, lat2: float, lng2: float) -> float:
# Internal helpers
# ---------------------------------------------------------------------------
+
@dataclass
class _SimResult:
"""Simulation result for a single day."""
+
travel_seconds: int
visit_order: list[str]
deep_dive: list[DeepDiveItem] = field(default_factory=list)
@@ -177,30 +186,34 @@ def _simulate_day(
# --- Safety margin check ---
minutes_before_close = place.close_minutes - arrive
if 0 < minutes_before_close < SAFETY_MARGIN_MINUTES and not place.is_depot:
- deep_dive.append(DeepDiveItem(
- fact=(
- f"'{place.name}' 도착 예정 {_minutes_to_hhmm(arrive)}, "
- f"영업 종료 {place.close} — {minutes_before_close:.0f}분 여유"
- ),
- rule="safety_margin",
- risk="CRITICAL",
- suggestion=(
- f"'{place.name}' 방문 순서를 앞당기거나 "
- f"체류 시간({place.stay_duration}분)을 줄이세요."
- ),
- ))
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"'{place.name}' 도착 예정 {_minutes_to_hhmm(arrive)}, "
+ f"영업 종료 {place.close} — {minutes_before_close:.0f}분 여유"
+ ),
+ rule="safety_margin",
+ risk="CRITICAL",
+ suggestion=(
+ f"'{place.name}' 방문 순서를 앞당기거나 "
+ f"체류 시간({place.stay_duration}분)을 줄이세요."
+ ),
+ )
+ )
# --- Time window infeasibility check ---
if arrive > place.close_minutes and not place.is_depot:
- deep_dive.append(DeepDiveItem(
- fact=(
- f"'{place.name}' 도착 예정 {_minutes_to_hhmm(arrive)}이나 "
- f"영업 종료는 {place.close}. 입장 불가."
- ),
- rule="time_window_infeasibility",
- risk="CRITICAL",
- suggestion=f"'{place.name}'을 더 이른 시간대로 이동하거나 일정에서 제외하세요.",
- ))
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"'{place.name}' 도착 예정 {_minutes_to_hhmm(arrive)}이나 "
+ f"영업 종료는 {place.close}. 입장 불가."
+ ),
+ rule="time_window_infeasibility",
+ risk="CRITICAL",
+ suggestion=f"'{place.name}'을 더 이른 시간대로 이동하거나 일정에서 제외하세요.",
+ )
+ )
# Wait until open if arrived early
effective_arrive = max(arrive, place.open_minutes)
@@ -241,6 +254,7 @@ def _compute_day_total_minutes(
# OR-Tools VRPTW solver (per-day, single-vehicle)
# ---------------------------------------------------------------------------
+
def _solve_vrptw_ortools(
places: list[VRPTWPlace],
matrix: TimeMatrix,
@@ -271,9 +285,9 @@ def _time_callback(from_idx: int, to_idx: int) -> int:
# OR-Tools AddDimension: (evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)
routing.AddDimension(
cb_idx,
- 24 * 3600, # slack_max (max waiting time)
- 24 * 3600, # capacity (max total time)
- False, # fix_start_cumul_to_zero
+ 24 * 3600, # slack_max (max waiting time)
+ 24 * 3600, # capacity (max total time)
+ False, # fix_start_cumul_to_zero
"Time",
)
time_dim = routing.GetDimensionOrDie("Time")
@@ -285,9 +299,7 @@ def _time_callback(from_idx: int, to_idx: int) -> int:
time_dim.CumulVar(idx).SetRange(open_sec, close_sec)
params = pywrapcp.DefaultRoutingSearchParameters()
- params.first_solution_strategy = (
- routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
- )
+ params.first_solution_strategy = routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
params.time_limit.seconds = 5
solution = routing.SolveWithParameters(params)
@@ -314,6 +326,7 @@ def _time_callback(from_idx: int, to_idx: int) -> int:
# Depot constraint checker
# ---------------------------------------------------------------------------
+
def _check_depot_constraints(
days: list[VRPTWDay],
) -> list[DeepDiveItem]:
@@ -336,37 +349,45 @@ def _has_depot(places: list[VRPTWPlace], position: str) -> bool:
if is_first_day:
# Day 1: must end at depot
if not _has_depot(places, "last"):
- issues.append(DeepDiveItem(
- fact=f"1일차 마지막 장소가 숙소(depot)가 아닙니다. ('{places[-1].name}')",
- rule="depot_constraint",
- risk="CRITICAL",
- suggestion="1일차 일정 마지막에 숙소 복귀를 추가하세요.",
- ))
+ issues.append(
+ DeepDiveItem(
+ fact=f"1일차 마지막 장소가 숙소(depot)가 아닙니다. ('{places[-1].name}')",
+ rule="depot_constraint",
+ risk="CRITICAL",
+ suggestion="1일차 일정 마지막에 숙소 복귀를 추가하세요.",
+ )
+ )
elif is_last_day:
# Last day: must start at depot
if not _has_depot(places, "first"):
- issues.append(DeepDiveItem(
- fact=f"마지막 날 첫 장소가 숙소(depot)가 아닙니다. ('{places[0].name}')",
- rule="depot_constraint",
- risk="CRITICAL",
- suggestion="마지막 날 일정은 숙소 출발로 시작해야 합니다.",
- ))
+ issues.append(
+ DeepDiveItem(
+ fact=f"마지막 날 첫 장소가 숙소(depot)가 아닙니다. ('{places[0].name}')",
+ rule="depot_constraint",
+ risk="CRITICAL",
+ suggestion="마지막 날 일정은 숙소 출발로 시작해야 합니다.",
+ )
+ )
else:
# Middle days: must start AND end at depot
if not _has_depot(places, "first"):
- issues.append(DeepDiveItem(
- fact=f"{day_idx + 1}일차 첫 장소가 숙소(depot)가 아닙니다. ('{places[0].name}')",
- rule="depot_constraint",
- risk="CRITICAL",
- suggestion=f"{day_idx + 1}일차는 숙소에서 출발해야 합니다.",
- ))
+ issues.append(
+ DeepDiveItem(
+ fact=f"{day_idx + 1}일차 첫 장소가 숙소(depot)가 아닙니다. ('{places[0].name}')",
+ rule="depot_constraint",
+ risk="CRITICAL",
+ suggestion=f"{day_idx + 1}일차는 숙소에서 출발해야 합니다.",
+ )
+ )
if not _has_depot(places, "last"):
- issues.append(DeepDiveItem(
- fact=f"{day_idx + 1}일차 마지막 장소가 숙소(depot)가 아닙니다. ('{places[-1].name}')",
- rule="depot_constraint",
- risk="CRITICAL",
- suggestion=f"{day_idx + 1}일차는 숙소로 귀환해야 합니다.",
- ))
+ issues.append(
+ DeepDiveItem(
+ fact=f"{day_idx + 1}일차 마지막 장소가 숙소(depot)가 아닙니다. ('{places[-1].name}')",
+ rule="depot_constraint",
+ risk="CRITICAL",
+ suggestion=f"{day_idx + 1}일차는 숙소로 귀환해야 합니다.",
+ )
+ )
return issues
@@ -375,6 +396,7 @@ def _has_depot(places: list[VRPTWPlace], position: str) -> bool:
# Main engine
# ---------------------------------------------------------------------------
+
class VRPTWEngine:
"""VRPTW-based travel itinerary validator.
@@ -402,13 +424,14 @@ def validate(self, request: VRPTWRequest) -> VRPTWResult:
# Depot constraint check
deep_dive.extend(_check_depot_constraints(request.days))
+ start_minutes = _time_to_minutes(request.start_time)
for day_idx, day in enumerate(request.days):
places = day.places
- start_min = DEFAULT_START_MINUTES
+ start_min = start_minutes
# Determine day start from depot open time if present
if places and places[0].is_depot:
- start_min = max(DEFAULT_START_MINUTES, places[0].open_minutes)
+ start_min = max(start_minutes, places[0].open_minutes)
# Simulate user route
user_sim = _simulate_day(places, self._matrix, start_min)
@@ -419,16 +442,18 @@ def validate(self, request: VRPTWRequest) -> VRPTWResult:
day_total_min = _compute_day_total_minutes(places, self._matrix, start_min)
if day_total_min > FATIGUE_HOURS_LIMIT * 60:
excess_h = (day_total_min - FATIGUE_HOURS_LIMIT * 60) / 60
- deep_dive.append(DeepDiveItem(
- fact=(
- f"{day_idx + 1}일차 총 소요 시간 {day_total_min:.0f}분 "
- f"({day_total_min/60:.1f}시간) — "
- f"{FATIGUE_HOURS_LIMIT}시간 초과 {excess_h:.1f}시간"
- ),
- rule="fatigue",
- risk="WARNING",
- suggestion="장소 수를 줄이거나 체류 시간을 단축해 일정을 12시간 이내로 조정하세요.",
- ))
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"{day_idx + 1}일차 총 소요 시간 {day_total_min:.0f}분 "
+ f"({day_total_min / 60:.1f}시간) — "
+ f"{FATIGUE_HOURS_LIMIT}시간 초과 {excess_h:.1f}시간"
+ ),
+ rule="fatigue",
+ risk="WARNING",
+ suggestion="장소 수를 줄이거나 체류 시간을 단축해 일정을 12시간 이내로 조정하세요.",
+ )
+ )
# OR-Tools optimal route
optimal_order: list[str] | None = None
@@ -440,33 +465,33 @@ def validate(self, request: VRPTWRequest) -> VRPTWResult:
if total_optimal_travel is not None:
total_optimal_travel += optimal_travel
- day_comparisons.append(DayRouteComparison(
- day_index=day_idx,
- user_order=[p.name for p in places],
- optimal_order=optimal_order,
- user_travel_seconds=user_sim.travel_seconds,
- optimal_travel_seconds=optimal_travel,
- ))
+ day_comparisons.append(
+ DayRouteComparison(
+ day_index=day_idx,
+ user_order=[p.name for p in places],
+ optimal_order=optimal_order,
+ user_travel_seconds=user_sim.travel_seconds,
+ optimal_travel_seconds=optimal_travel,
+ )
+ )
# Efficiency gap
efficiency_gap: float | None = None
- if (
- total_optimal_travel is not None
- and total_optimal_travel > 0
- and total_user_travel > 0
- ):
+ if total_optimal_travel is not None and total_optimal_travel > 0 and total_user_travel > 0:
efficiency_gap = (total_user_travel - total_optimal_travel) / total_optimal_travel
if efficiency_gap > EFFICIENCY_GAP_THRESHOLD:
- deep_dive.append(DeepDiveItem(
- fact=(
- f"사용자 이동 시간 {total_user_travel}초 vs "
- f"최적 {total_optimal_travel}초 "
- f"(효율성 격차 {efficiency_gap:.1%})"
- ),
- rule="efficiency_gap",
- risk="WARNING",
- suggestion="VRPTW 최적 순서를 참고해 방문 순서를 재배치하세요.",
- ))
+ deep_dive.append(
+ DeepDiveItem(
+ fact=(
+ f"사용자 이동 시간 {total_user_travel}초 vs "
+ f"최적 {total_optimal_travel}초 "
+ f"(효율성 격차 {efficiency_gap:.1%})"
+ ),
+ rule="efficiency_gap",
+ risk="WARNING",
+ suggestion="VRPTW 최적 순서를 참고해 방문 순서를 재배치하세요.",
+ )
+ )
# Risk score
risk_score = self._compute_risk_score(deep_dive, efficiency_gap, request.days)
@@ -514,7 +539,7 @@ def _compute_risk_score(
# Fatigue: extra deduction already encoded in deep_dive above;
# additionally compute raw fatigue hours across all days
- for day_idx, day in enumerate(days):
+ for _day_idx, day in enumerate(days):
day_total_min = _compute_day_total_minutes(
day.places, self._matrix, DEFAULT_START_MINUTES
)
diff --git a/src/validation/warning.py b/src/validation/warning.py
index e309342..4a95668 100644
--- a/src/validation/warning.py
+++ b/src/validation/warning.py
@@ -1,36 +1,38 @@
"""Warning 탐지기 (동선 비효율·일정 과밀·체력 부담·목적 부적합·구역 재방문)."""
+
from __future__ import annotations
-from src.data.models import ItineraryPlan, POI, Warning
+from src.data.models import POI, ItineraryPlan, Warning
from src.data.party_config import get_party_profile
-from src.utils.geo import build_dist_cache, get_travel_min, haversine_km, nn_heuristic_km
+from src.utils.geo import build_dist_cache, get_travel_min, nn_heuristic_km
DEFAULT_START_MINUTES: int = 9 * 60 # 09:00
WARNING_TYPES = {
- "DENSE_SCHEDULE": ("일정 과밀", "Medium"),
- "INEFFICIENT_ROUTE": ("동선 비효율", "Medium"),
- "PHYSICAL_STRAIN": ("체력 부담", "Medium"),
- "PURPOSE_MISMATCH": ("목적 부적합", "Medium-Low"),
- "AREA_REVISIT": ("구역 재방문", "Medium"),
- "CUMULATIVE_FATIGUE": ("누적 피로도", "Medium"),
+ "DENSE_SCHEDULE": ("일정 과밀", "Medium"),
+ "INEFFICIENT_ROUTE": ("동선 비효율", "Medium"),
+ "PHYSICAL_STRAIN": ("체력 부담", "Medium"),
+ "PURPOSE_MISMATCH": ("목적 부적합", "Medium-Low"),
+ "AREA_REVISIT": ("구역 재방문", "Medium"),
+ "CUMULATIVE_FATIGUE": ("누적 피로도", "Medium"),
}
INTENT_VECTORS: dict[str, dict[str, float]] = {
- "cultural": {"14": 0.6, "12": 0.2, "15": 0.1, "other": 0.1},
- "nature": {"12": 0.5, "15": 0.3, "14": 0.1, "other": 0.1},
- "shopping": {"38": 0.5, "12": 0.3, "14": 0.1, "other": 0.1},
- "food": {"39": 0.6, "12": 0.2, "14": 0.1, "other": 0.1},
+ "cultural": {"14": 0.6, "12": 0.2, "15": 0.1, "other": 0.1},
+ "nature": {"12": 0.5, "15": 0.3, "14": 0.1, "other": 0.1},
+ "shopping": {"38": 0.5, "12": 0.3, "14": 0.1, "other": 0.1},
+ "food": {"39": 0.6, "12": 0.2, "14": 0.1, "other": 0.1},
"adventure": {"15": 0.6, "12": 0.2, "14": 0.1, "other": 0.1},
}
def _cosine_distance(v1: dict[str, float], v2: dict[str, float]) -> float:
import math
+
keys = set(v1) | set(v2)
dot = sum(v1.get(k, 0.0) * v2.get(k, 0.0) for k in keys)
- norm1 = math.sqrt(sum(x ** 2 for x in v1.values()))
- norm2 = math.sqrt(sum(x ** 2 for x in v2.values()))
+ norm1 = math.sqrt(sum(x**2 for x in v1.values()))
+ norm2 = math.sqrt(sum(x**2 for x in v2.values()))
if norm1 == 0 or norm2 == 0:
return 1.0
return 1.0 - dot / (norm1 * norm2)
@@ -44,9 +46,9 @@ class WarningDetector:
"""
STRAIN_THRESHOLD_KM: float = 30.0 # 기준 그룹(혼자/친구) 체력 부담 임계
- BACKTRACK_THRESHOLD: float = 0.3 # 30% 초과 이동거리 비효율
+ BACKTRACK_THRESHOLD: float = 0.3 # 30% 초과 이동거리 비효율
PURPOSE_FIT_THRESHOLD: float = 0.5
- CONSECUTIVE_REVISIT: int = 3 # 같은 카테고리 연속 ≥ 3회 (2회는 문화투어 등에서 false positive)
+ CONSECUTIVE_REVISIT: int = 3 # 같은 카테고리 연속 ≥ 3회 (2회는 문화투어 등에서 false positive)
def detect(
self,
@@ -88,14 +90,16 @@ def _check_dense_schedule(
if total_min <= threshold_min:
return []
_, confidence = WARNING_TYPES["DENSE_SCHEDULE"]
- return [Warning(
- warning_type="DENSE_SCHEDULE",
- message=(
- f"총 일정 소요 시간 {total_min:.0f}분 ({total_min / 60:.1f}시간)이 "
- f"'{plan.party_type}' 그룹 피로도 한계 {profile.fatigue_hours}시간을 초과합니다."
- ),
- confidence=confidence,
- )]
+ return [
+ Warning(
+ warning_type="DENSE_SCHEDULE",
+ message=(
+ f"총 일정 소요 시간 {total_min:.0f}분 ({total_min / 60:.1f}시간)이 "
+ f"'{plan.party_type}' 그룹 피로도 한계 {profile.fatigue_hours}시간을 초과합니다."
+ ),
+ confidence=confidence,
+ )
+ ]
def _check_inefficient_route(
self,
@@ -112,14 +116,16 @@ def _check_inefficient_route(
if ratio <= self.BACKTRACK_THRESHOLD:
return []
_, confidence = WARNING_TYPES["INEFFICIENT_ROUTE"]
- return [Warning(
- warning_type="INEFFICIENT_ROUTE",
- message=(
- f"현재 방문 순서의 이동 거리({actual_km:.1f}km)가 최적 경로 대비 "
- f"{ratio:.1%} 더 깁니다. 방문 순서를 재배치해 보세요."
- ),
- confidence=confidence,
- )]
+ return [
+ Warning(
+ warning_type="INEFFICIENT_ROUTE",
+ message=(
+ f"현재 방문 순서의 이동 거리({actual_km:.1f}km)가 최적 경로 대비 "
+ f"{ratio:.1%} 더 깁니다. 방문 순서를 재배치해 보세요."
+ ),
+ confidence=confidence,
+ )
+ ]
def _check_physical_strain(
self,
@@ -133,14 +139,16 @@ def _check_physical_strain(
if total_km <= threshold_km:
return []
_, confidence = WARNING_TYPES["PHYSICAL_STRAIN"]
- return [Warning(
- warning_type="PHYSICAL_STRAIN",
- message=(
- f"총 이동 거리 {total_km:.1f}km가 "
- f"'{plan.party_type}' 그룹 체력 한계 {threshold_km:.0f}km를 초과합니다."
- ),
- confidence=confidence,
- )]
+ return [
+ Warning(
+ warning_type="PHYSICAL_STRAIN",
+ message=(
+ f"총 이동 거리 {total_km:.1f}km가 "
+ f"'{plan.party_type}' 그룹 체력 한계 {threshold_km:.0f}km를 초과합니다."
+ ),
+ confidence=confidence,
+ )
+ ]
def _check_purpose_mismatch(self, plan: ItineraryPlan, pois: list[POI]) -> list[Warning]:
if not plan.travel_type:
@@ -164,14 +172,16 @@ def _check_purpose_mismatch(self, plan: ItineraryPlan, pois: list[POI]) -> list[
if purpose_fit >= self.PURPOSE_FIT_THRESHOLD:
return []
_, confidence = WARNING_TYPES["PURPOSE_MISMATCH"]
- return [Warning(
- warning_type="PURPOSE_MISMATCH",
- message=(
- f"여행 테마 '{plan.travel_type}'과 실제 장소 구성의 일치도가 "
- f"{purpose_fit:.2f}로 낮습니다. 테마에 맞는 장소 선택을 권장합니다."
- ),
- confidence=confidence,
- )]
+ return [
+ Warning(
+ warning_type="PURPOSE_MISMATCH",
+ message=(
+ f"여행 테마 '{plan.travel_type}'과 실제 장소 구성의 일치도가 "
+ f"{purpose_fit:.2f}로 낮습니다. 테마에 맞는 장소 선택을 권장합니다."
+ ),
+ confidence=confidence,
+ )
+ ]
def check_cumulative_fatigue(
self,
@@ -208,32 +218,38 @@ def check_cumulative_fatigue(
max_run = max(max_run, run)
if max_run >= ABUSE_RUN:
- return [Warning(
- warning_type="CUMULATIVE_FATIGUE",
- message=(
- f"{max_run}일 연속으로 일일 피로도 한계의 {int(HIGH*100)}% 이상인 일정이 감지되었습니다. "
- f"'{plan.party_type}' 그룹에게 심각한 누적 피로가 예상됩니다. "
- "중간에 여유 있는 반나절 일정을 넣어보세요."
- ),
- confidence="Medium",
- )]
+ return [
+ Warning(
+ warning_type="CUMULATIVE_FATIGUE",
+ message=(
+ f"{max_run}일 연속으로 일일 피로도 한계의 {int(HIGH * 100)}% 이상인 일정이 감지되었습니다. "
+ f"'{plan.party_type}' 그룹에게 심각한 누적 피로가 예상됩니다. "
+ "중간에 여유 있는 반나절 일정을 넣어보세요."
+ ),
+ confidence="Medium",
+ )
+ ]
# 전날 매우 강도 높음(>85%) + 다음날도 상당(>60%) → carry-over 경고
VERY_HIGH = 0.85
MODERATE = 0.60
for i in range(1, len(intensities)):
if intensities[i - 1] > VERY_HIGH and intensities[i] > MODERATE:
- return [Warning(
- warning_type="CUMULATIVE_FATIGUE",
- message=(
- f"{i}일차 일정이 피로도 한계의 {intensities[i-1]:.0%}로 매우 고강도였고, "
- f"{i+1}일차도 {intensities[i]:.0%} 강도로 계획되어 있습니다. "
- "전날 피로가 이월되어 컨디션이 저하될 수 있습니다."
- ),
- confidence="Medium",
- day_index=i,
- poi_names=[p.name for p in per_day_pois[i]] if i < len(per_day_pois) else [],
- )]
+ return [
+ Warning(
+ warning_type="CUMULATIVE_FATIGUE",
+ message=(
+ f"{i}일차 일정이 피로도 한계의 {intensities[i - 1]:.0%}로 매우 고강도였고, "
+ f"{i + 1}일차도 {intensities[i]:.0%} 강도로 계획되어 있습니다. "
+ "전날 피로가 이월되어 컨디션이 저하될 수 있습니다."
+ ),
+ confidence="Medium",
+ day_index=i,
+ poi_names=[p.name for p in per_day_pois[i]]
+ if i < len(per_day_pois)
+ else [],
+ )
+ ]
return []
@@ -254,11 +270,13 @@ def _check_area_revisit(self, pois: list[POI]) -> list[Warning]:
if max_run < self.CONSECUTIVE_REVISIT:
return []
_, confidence = WARNING_TYPES["AREA_REVISIT"]
- return [Warning(
- warning_type="AREA_REVISIT",
- message=(
- f"동일 카테고리 장소가 {max_run}회 연속 배치되어 있습니다. "
- "다양한 유형의 장소를 번갈아 방문하면 여행이 더 풍성해집니다."
- ),
- confidence=confidence,
- )]
+ return [
+ Warning(
+ warning_type="AREA_REVISIT",
+ message=(
+ f"동일 카테고리 장소가 {max_run}회 연속 배치되어 있습니다. "
+ "다양한 유형의 장소를 번갈아 방문하면 여행이 더 풍성해집니다."
+ ),
+ confidence=confidence,
+ )
+ ]
diff --git a/tests/conftest.py b/tests/conftest.py
index 66a87a9..bd8863f 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -4,6 +4,7 @@
그 모듈을 import하는 테스트가 먼저 수집되면 이후 테스트의 "키 없음" 케이스가
실행 순서에 따라 랜덤하게 깨진다 — 매 테스트마다 강제로 지워 격리한다.
"""
+
import pytest
diff --git a/tests/test_alternatives.py b/tests/test_alternatives.py
index 677ef86..0732c7a 100644
--- a/tests/test_alternatives.py
+++ b/tests/test_alternatives.py
@@ -1,9 +1,8 @@
"""AlternativesFinder 유닛 테스트."""
-from __future__ import annotations
-import pytest
+from __future__ import annotations
-from src.data.models import AlternativePOI, HardFail, POI
+from src.data.models import POI, HardFail
from src.validation.alternatives import AlternativesFinder
@@ -40,7 +39,7 @@ class TestFindAlternatives:
def test_returns_nearby_same_category(self):
pool = [
_poi("B", lat=37.502, lng=127.0, category="14"),
- _poi("C", lat=37.6, lng=127.0, category="12"),
+ _poi("C", lat=37.6, lng=127.0, category="12"),
]
finder = AlternativesFinder(poi_pool=pool)
failed = _poi("A", lat=37.5, lng=127.0, category="14")
diff --git a/tests/test_api_schemas.py b/tests/test_api_schemas.py
new file mode 100644
index 0000000..5ad4386
--- /dev/null
+++ b/tests/test_api_schemas.py
@@ -0,0 +1,36 @@
+"""API 입력 스키마의 경계값 검증."""
+
+import pytest
+from pydantic import ValidationError
+
+from src.api.schemas import ValidateRequest
+
+
+def _request(**overrides):
+ data = {
+ "days": [{"places": [{"name": "경복궁"}]}],
+ "party_size": 2,
+ "party_type": "친구",
+ "travel_type": "cultural",
+ "date": "2026-05-10",
+ "start_time": "09:00",
+ }
+ data.update(overrides)
+ return ValidateRequest(**data)
+
+
+def test_date_and_start_time_are_validated():
+ with pytest.raises(ValidationError):
+ _request(date="not-a-date")
+ with pytest.raises(ValidationError):
+ _request(start_time="99:99")
+
+
+def test_empty_day_is_rejected_at_request_boundary():
+ with pytest.raises(ValidationError):
+ _request(days=[{"places": []}])
+
+
+def test_place_name_cannot_be_blank():
+ with pytest.raises(ValidationError):
+ _request(days=[{"places": [{"name": " "}]}])
diff --git a/tests/test_bonus_engine.py b/tests/test_bonus_engine.py
index 0cd0af4..4eb3ddf 100644
--- a/tests/test_bonus_engine.py
+++ b/tests/test_bonus_engine.py
@@ -1,16 +1,15 @@
"""Tests for BonusEngine (TDD)."""
+
from __future__ import annotations
import json
import tempfile
from pathlib import Path
-import pytest
-
from src.data.models import POI
from src.scoring.bonus_engine import (
- ACCESSIBLE_PARTY_TYPES,
ACCESSIBILITY_BONUS_PER_PLACE,
+ ACCESSIBLE_PARTY_TYPES,
BONUS_CAP,
PET_FRIENDLY_BONUS_PER_PLACE,
WELLNESS_BONUS_PER_PLACE,
@@ -20,12 +19,18 @@
def make_poi(
- poi_id: str = "1", lat: float = 37.5, lng: float = 127.0, pet_friendly: bool = False,
+ poi_id: str = "1",
+ lat: float = 37.5,
+ lng: float = 127.0,
+ pet_friendly: bool = False,
) -> POI:
return POI(
- poi_id=poi_id, name=f"POI_{poi_id}",
- lat=lat, lng=lng,
- open_start="09:00", open_end="18:00",
+ poi_id=poi_id,
+ name=f"POI_{poi_id}",
+ lat=lat,
+ lng=lng,
+ open_start="09:00",
+ open_end="18:00",
duration_min=60,
pet_friendly=pet_friendly,
)
@@ -44,6 +49,7 @@ def make_engine(
# BonusEngine.compute() — wellness bonus
# ---------------------------------------------------------------------------
+
class TestWellnessBonus:
def test_no_wellness_data_gives_zero(self):
engine = make_engine(wellness_coords=[])
@@ -92,6 +98,7 @@ def test_wellness_applies_to_all_party_types(self):
# BonusEngine.compute() — accessibility bonus
# ---------------------------------------------------------------------------
+
class TestAccessibilityBonus:
def test_accessible_party_gets_bonus(self):
engine = make_engine(barrier_free_coords=[(37.5, 127.0)])
@@ -119,6 +126,7 @@ def test_accessibility_bonus_capped(self):
# BonusEngine.compute() — pet-friendly bonus (가산점만, 감점 없음)
# ---------------------------------------------------------------------------
+
class TestPetFriendlyBonus:
def test_disabled_gives_zero_even_if_matched(self):
engine = make_engine()
@@ -156,6 +164,7 @@ def test_pet_friendly_matched_names_populated(self):
# BonusEngine.compute() — total_bonus cap
# ---------------------------------------------------------------------------
+
class TestTotalBonusCap:
def test_combined_bonus_capped_at_cap(self):
coords = [(37.5 + i * 0.01, 127.0) for i in range(20)]
@@ -174,9 +183,7 @@ def test_total_is_sum_when_under_cap(self):
make_poi("2", 37.51, 127.0),
]
result = engine.compute(pois, party_type="아기동반")
- expected_total = min(
- result.wellness_bonus + result.accessibility_bonus, BONUS_CAP
- )
+ expected_total = min(result.wellness_bonus + result.accessibility_bonus, BONUS_CAP)
assert result.total_bonus == expected_total
@@ -184,6 +191,7 @@ def test_total_is_sum_when_under_cap(self):
# BonusEngine.from_dataset()
# ---------------------------------------------------------------------------
+
class TestFromDataset:
def test_missing_files_give_empty_engine(self):
engine = BonusEngine.from_dataset(
@@ -214,7 +222,9 @@ def test_zero_coords_skipped(self):
wp = Path(tmp) / "wellness.json"
wp.write_text(json.dumps(records), encoding="utf-8")
- engine = BonusEngine.from_dataset(wellness_path=wp, barrier_free_path="nonexistent.json")
+ engine = BonusEngine.from_dataset(
+ wellness_path=wp, barrier_free_path="nonexistent.json"
+ )
pois = [make_poi("1", 37.5, 127.0)]
result = engine.compute(pois, party_type="친구")
assert result.wellness_bonus == 0
@@ -224,6 +234,7 @@ def test_zero_coords_skipped(self):
# BonusResult fields
# ---------------------------------------------------------------------------
+
class TestBonusResultFields:
def test_matched_names_populated(self):
engine = make_engine(wellness_coords=[(37.5, 127.0)])
diff --git a/tests/test_cluster_dispersion.py b/tests/test_cluster_dispersion.py
index 0d60bf1..212e84d 100644
--- a/tests/test_cluster_dispersion.py
+++ b/tests/test_cluster_dispersion.py
@@ -1,14 +1,14 @@
"""Tests for src/scoring/cluster_dispersion.py — per-day 검증."""
+
from __future__ import annotations
import pytest
from src.data.models import VRPTWDay, VRPTWPlace
from src.scoring.cluster_dispersion import (
+ _SKLEARN_AVAILABLE,
COMBINED_PENALTY_CAP,
- PENALTY_DIST_CRIT,
PENALTY_SWITCH_WARN,
- _SKLEARN_AVAILABLE,
count_geo_cluster_backtracks,
evaluate_cluster_dispersion,
)
@@ -16,19 +16,26 @@
def _make_place(name: str, lng: float, lat: float):
return VRPTWPlace(
- name=name, lng=lng, lat=lat,
- open="09:00", close="22:00", stay_duration=60, is_depot=False,
+ name=name,
+ lng=lng,
+ lat=lat,
+ open="09:00",
+ close="22:00",
+ stay_duration=60,
+ is_depot=False,
)
def test_compact_day_no_penalty():
"""같은 시군구 + 거리 < 30km → 패널티 0."""
- day = VRPTWDay(places=[
- _make_place("강남A", 127.027, 37.498),
- _make_place("강남B", 127.030, 37.500),
- _make_place("강남C", 127.025, 37.495),
- ])
- sg = [["680", "680", "680"]] # 모두 강남구
+ day = VRPTWDay(
+ places=[
+ _make_place("강남A", 127.027, 37.498),
+ _make_place("강남B", 127.030, 37.500),
+ _make_place("강남C", 127.025, 37.495),
+ ]
+ )
+ sg = [["680", "680", "680"]] # 모두 강남구
report = evaluate_cluster_dispersion([day], sigungu_codes_per_day=sg)
assert report.total_penalty == 0
assert report.per_day[0].sigungu_switches == 0
@@ -37,12 +44,14 @@ def test_compact_day_no_penalty():
def test_lightning_pattern_high_penalty():
"""1일차에 서울↔부산 섞기 → 거리 메트릭 CRITICAL + 캡 적용."""
- day = VRPTWDay(places=[
- _make_place("서울 강남", 127.027, 37.498),
- _make_place("부산 해운대", 129.157, 35.158),
- _make_place("서울 종로", 126.984, 37.572),
- ])
- sg = [["680", "260", "110"]] # 강남구 → 해운대구 → 종로구
+ day = VRPTWDay(
+ places=[
+ _make_place("서울 강남", 127.027, 37.498),
+ _make_place("부산 해운대", 129.157, 35.158),
+ _make_place("서울 종로", 126.984, 37.572),
+ ]
+ )
+ sg = [["680", "260", "110"]] # 강남구 → 해운대구 → 종로구
report = evaluate_cluster_dispersion([day], sigungu_codes_per_day=sg)
# 서울↔부산 직선거리 ~325km → CRITICAL
assert report.per_day[0].max_pairwise_km > 100
@@ -52,14 +61,18 @@ def test_lightning_pattern_high_penalty():
def test_per_day_independence():
"""Day1=서울 / Day2=부산 (각 day 안에서는 응집) → 패널티 없음."""
- day1 = VRPTWDay(places=[
- _make_place("서울A", 127.027, 37.498),
- _make_place("서울B", 127.030, 37.500),
- ])
- day2 = VRPTWDay(places=[
- _make_place("부산A", 129.157, 35.158),
- _make_place("부산B", 129.160, 35.160),
- ])
+ day1 = VRPTWDay(
+ places=[
+ _make_place("서울A", 127.027, 37.498),
+ _make_place("서울B", 127.030, 37.500),
+ ]
+ )
+ day2 = VRPTWDay(
+ places=[
+ _make_place("부산A", 129.157, 35.158),
+ _make_place("부산B", 129.160, 35.160),
+ ]
+ )
sg = [["680", "680"], ["260", "260"]]
report = evaluate_cluster_dispersion([day1, day2], sigungu_codes_per_day=sg)
assert report.total_penalty == 0
@@ -68,12 +81,14 @@ def test_per_day_independence():
@pytest.mark.skipif(not _SKLEARN_AVAILABLE, reason="sklearn not installed")
def test_geo_cluster_backtrack_gyeongju():
"""M4: 경주 — 동일 시군구지만 지리적으로 분산 왕복 → M3=0인데 M4≥1."""
- day = VRPTWDay(places=[
- _make_place("첨성대", 129.2191, 35.8347), # 경주 시내
- _make_place("감포해수욕장", 129.5007, 35.7914), # 경주 동해안 ~28km
- _make_place("안압지", 129.2246, 35.8344), # 경주 시내 (재방문)
- _make_place("불국사", 129.3317, 35.7896), # 중간
- ])
+ day = VRPTWDay(
+ places=[
+ _make_place("첨성대", 129.2191, 35.8347), # 경주 시내
+ _make_place("감포해수욕장", 129.5007, 35.7914), # 경주 동해안 ~28km
+ _make_place("안압지", 129.2246, 35.8344), # 경주 시내 (재방문)
+ _make_place("불국사", 129.3317, 35.7896), # 중간
+ ]
+ )
# 모두 경주시 → M3=0, M2=25km대 (30km 미만 → 패널티 없음)
sg = [["경주시", "경주시", "경주시", "경주시"]]
report = evaluate_cluster_dispersion([day], sigungu_codes_per_day=sg)
@@ -89,12 +104,14 @@ def test_geo_cluster_backtrack_gyeongju():
@pytest.mark.skipif(not _SKLEARN_AVAILABLE, reason="sklearn not installed")
def test_geo_cluster_no_false_positive_sequential():
"""M4 false positive: 강남→홍대 순방향 방문은 패널티 없어야."""
- day = VRPTWDay(places=[
- _make_place("강남역", 127.0276, 37.4979),
- _make_place("코엑스", 127.0590, 37.5115),
- _make_place("홍대입구", 126.9248, 37.5574),
- _make_place("연남동", 126.9259, 37.5634),
- ])
+ day = VRPTWDay(
+ places=[
+ _make_place("강남역", 127.0276, 37.4979),
+ _make_place("코엑스", 127.0590, 37.5115),
+ _make_place("홍대입구", 126.9248, 37.5574),
+ _make_place("연남동", 126.9259, 37.5634),
+ ]
+ )
bt = count_geo_cluster_backtracks(day.places)
assert bt == 0, "순방향 방문은 지리 클러스터 백트래킹 0"
@@ -107,11 +124,13 @@ def test_geo_cluster_no_double_penalty_when_m3_fires():
M3: 강남→마포→강남 = 1회 탐지. M4도 동일 이벤트 탐지.
→ geo_pen = max(0, 1 - 1) = 0 → M4 DeepDive 없어야.
"""
- day = VRPTWDay(places=[
- _make_place("강남역", 127.0276, 37.4979), # cluster A
- _make_place("홍대입구", 126.9248, 37.5574), # cluster B
- _make_place("역삼역", 127.0368, 37.5006), # cluster A (~0.9km from 강남역)
- ])
+ day = VRPTWDay(
+ places=[
+ _make_place("강남역", 127.0276, 37.4979), # cluster A
+ _make_place("홍대입구", 126.9248, 37.5574), # cluster B
+ _make_place("역삼역", 127.0368, 37.5006), # cluster A (~0.9km from 강남역)
+ ]
+ )
sg = [["강남구", "마포구", "강남구"]]
report = evaluate_cluster_dispersion([day], sigungu_codes_per_day=sg)
m = report.per_day[0]
@@ -124,14 +143,16 @@ def test_geo_cluster_no_double_penalty_when_m3_fires():
def test_sigungu_switches_only():
"""거리는 안 멀지만 시군구 전환 4회+ → 시군구 패널티만 발생."""
- day = VRPTWDay(places=[
- _make_place("A", 127.00, 37.55), # 강남
- _make_place("B", 127.01, 37.56), # 송파 (10km 미만)
- _make_place("C", 127.02, 37.57), # 광진 (10km 미만)
- _make_place("D", 127.03, 37.58), # 성동 (10km 미만)
- _make_place("E", 127.04, 37.59), # 중구 (10km 미만)
- ])
- sg = [["680", "710", "215", "200", "140"]] # 5개 다른 시군구 → 4회 전환
+ day = VRPTWDay(
+ places=[
+ _make_place("A", 127.00, 37.55), # 강남
+ _make_place("B", 127.01, 37.56), # 송파 (10km 미만)
+ _make_place("C", 127.02, 37.57), # 광진 (10km 미만)
+ _make_place("D", 127.03, 37.58), # 성동 (10km 미만)
+ _make_place("E", 127.04, 37.59), # 중구 (10km 미만)
+ ]
+ )
+ sg = [["680", "710", "215", "200", "140"]] # 5개 다른 시군구 → 4회 전환
report = evaluate_cluster_dispersion([day], sigungu_codes_per_day=sg)
assert report.per_day[0].sigungu_switches == 4
assert report.total_penalty >= PENALTY_SWITCH_WARN
diff --git a/tests/test_congestion_engine.py b/tests/test_congestion_engine.py
index 6c188b2..345e298 100644
--- a/tests/test_congestion_engine.py
+++ b/tests/test_congestion_engine.py
@@ -1,8 +1,8 @@
"""Unit tests for CongestionEngine."""
+
from __future__ import annotations
from pathlib import Path
-from unittest.mock import patch
import pandas as pd
import pytest
@@ -23,20 +23,14 @@
"poi_name": ["경복궁"] * 12 + ["남산타워"] * 12 + ["해운대"] * 12,
"month": list(range(1, 13)) * 3,
"avg_visitors": (
- [10000, 11000, 15000, 30000, 45000, 35000,
- 30000, 32000, 40000, 50000, 20000, 12000]
- + [5000, 5500, 7000, 12000, 18000, 14000,
- 12000, 13000, 16000, 20000, 8000, 5000]
- + [8000, 8500, 9000, 15000, 20000, 25000,
- 90000, 95000, 30000, 18000, 9000, 8000]
+ [10000, 11000, 15000, 30000, 45000, 35000, 30000, 32000, 40000, 50000, 20000, 12000]
+ + [5000, 5500, 7000, 12000, 18000, 14000, 12000, 13000, 16000, 20000, 8000, 5000]
+ + [8000, 8500, 9000, 15000, 20000, 25000, 90000, 95000, 30000, 18000, 9000, 8000]
),
"congestion_score": (
- [0.2, 0.22, 0.30, 0.60, 1.00, 0.70,
- 0.60, 0.64, 0.80, 1.00, 0.40, 0.24]
- + [0.25, 0.275, 0.35, 0.60, 0.90, 0.70,
- 0.60, 0.65, 0.80, 1.00, 0.40, 0.25]
- + [0.084, 0.090, 0.095, 0.158, 0.211, 0.263,
- 1.000, 1.000, 0.316, 0.190, 0.095, 0.084]
+ [0.2, 0.22, 0.30, 0.60, 1.00, 0.70, 0.60, 0.64, 0.80, 1.00, 0.40, 0.24]
+ + [0.25, 0.275, 0.35, 0.60, 0.90, 0.70, 0.60, 0.65, 0.80, 1.00, 0.40, 0.25]
+ + [0.084, 0.090, 0.095, 0.158, 0.211, 0.263, 1.000, 1.000, 0.316, 0.190, 0.095, 0.084]
),
"annual_max": [50000 * 12] * 12 + [20000 * 12] * 12 + [95000 * 12] * 12,
"annual_min": [10000 * 12] * 12 + [5000 * 12] * 12 + [8000 * 12] * 12,
@@ -55,6 +49,7 @@ def engine(tmp_path):
# _score_to_level
# ──────────────────────────────────────────────
+
@pytest.mark.parametrize(
"score,expected",
[
@@ -76,6 +71,7 @@ def test_score_to_level(score, expected):
# Exact match
# ──────────────────────────────────────────────
+
def test_exact_match(engine):
result = engine.score("경복궁", 10)
assert result.fallback_used == "exact"
@@ -95,6 +91,7 @@ def test_exact_match_low_season(engine):
# Partial match
# ──────────────────────────────────────────────
+
def test_partial_match_substring(engine):
result = engine.score("경복", 5)
assert result.fallback_used == "partial"
@@ -111,6 +108,7 @@ def test_partial_match_superstring(engine):
# Category / global fallback
# ──────────────────────────────────────────────
+
def test_global_fallback(engine):
result = engine.score("존재하지않는관광지XYZ", 6)
assert result.fallback_used in ("category", "global")
@@ -127,6 +125,7 @@ def test_category_fallback(engine):
# Validation
# ──────────────────────────────────────────────
+
def test_invalid_month_raises(engine):
with pytest.raises(ValueError, match="month must be 1-12"):
engine.score("경복궁", 0)
@@ -144,6 +143,7 @@ def test_result_is_dataclass(engine):
# is_crowded / batch
# ──────────────────────────────────────────────
+
def test_is_crowded_true(engine):
assert engine.is_crowded("경복궁", 10, threshold=0.7) is True
@@ -162,6 +162,7 @@ def test_score_itinerary(engine):
# Missing CSV
# ──────────────────────────────────────────────
+
def test_missing_csv_raises():
engine = CongestionEngine(csv_path=Path("/nonexistent/path.csv"))
with pytest.raises(FileNotFoundError, match="혼잡도 데이터 없음"):
diff --git a/tests/test_dwell_db.py b/tests/test_dwell_db.py
index 64a24f2..6a6ee8a 100644
--- a/tests/test_dwell_db.py
+++ b/tests/test_dwell_db.py
@@ -1,13 +1,11 @@
"""Tests for src/data/dwell_db.py — 5단계 폴백 검증."""
-from __future__ import annotations
-import pytest
+from __future__ import annotations
from src.data.dwell_db import (
BY_LCLS1,
BY_LCLS3,
DEFAULT_DWELL,
- MANUAL_OVERRIDES,
DwellRecommendation,
get_recommended_dwell,
)
@@ -65,5 +63,5 @@ def test_no_info_returns_default(self):
class TestIsTooShort:
def test_below_50pct_is_too_short(self):
rec = DwellRecommendation(min_minutes=90, max_minutes=150, source="manual")
- assert rec.is_too_short(30) is True # 30 < 90*0.5=45
+ assert rec.is_too_short(30) is True # 30 < 90*0.5=45
assert rec.is_too_short(60) is False # 60 >= 45
diff --git a/tests/test_estimated_hardfail.py b/tests/test_estimated_hardfail.py
index 72017fa..d8d6909 100644
--- a/tests/test_estimated_hardfail.py
+++ b/tests/test_estimated_hardfail.py
@@ -1,7 +1,8 @@
"""P1: 추정 영업시간 충돌의 하드페일 강등 테스트."""
+
from __future__ import annotations
-from src.data.models import DayPlan, ItineraryPlan, PlaceInput, POI
+from src.data.models import POI, DayPlan, ItineraryPlan, PlaceInput
from src.validation.hard_fail import HardFailDetector
diff --git a/tests/test_explain_engine.py b/tests/test_explain_engine.py
index 67f60da..fb5dc51 100644
--- a/tests/test_explain_engine.py
+++ b/tests/test_explain_engine.py
@@ -1,10 +1,9 @@
"""Tests for ExplainEngine (TDD) — LLM은 mock으로 대체."""
+
from __future__ import annotations
import json
-from unittest.mock import MagicMock, patch
-
-import pytest
+from unittest.mock import MagicMock
from src.data.models import (
AlternativePOI,
@@ -26,11 +25,11 @@
_parse_llm_response,
)
-
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
+
def make_plan() -> ItineraryPlan:
return ItineraryPlan(
days=[DayPlan(places=[PlaceInput(name="경복궁"), PlaceInput(name="남산공원")])],
@@ -63,19 +62,25 @@ def make_warning() -> Warning:
def make_graph_stub(with_nearby: bool = True) -> MagicMock:
- """GraphRetriever 스텁 — 실제 Neo4j 연결 없이 성산일출봉 검색 결과를 흉내낸다."""
+ """근거 리트리버 스텁 — 외부 서비스 없이 장소 검색 결과를 흉내낸다."""
graph = MagicMock()
graph.enabled = True
graph.search_places.return_value = [
PlaceEvidence(
- place_id="kakao_1", name="성산일출봉", place_type="ACTIVITY",
- category_name="자연관광지", region_name="성산읍",
- address="제주 서귀포시 성산읍", lat=33.458, lng=126.942,
+ place_id="kakao_1",
+ name="성산일출봉",
+ place_type="ACTIVITY",
+ category_name="자연관광지",
+ region_name="성산읍",
+ address="제주 서귀포시 성산읍",
+ lat=33.458,
+ lng=126.942,
)
]
graph.find_nearby.return_value = (
[AlternativePOI(name="우도", distance_km=0.25, category="자연관광지", lat=33.5, lng=126.95)]
- if with_nearby else []
+ if with_nearby
+ else []
)
return graph
@@ -90,6 +95,7 @@ def make_disabled_graph_stub() -> MagicMock:
# _cache_key
# ---------------------------------------------------------------------------
+
class TestCacheKey:
def test_same_inputs_same_key(self):
hf = [make_hard_fail()]
@@ -117,6 +123,7 @@ def test_different_day_index_different_key(self):
# _graph_context
# ---------------------------------------------------------------------------
+
class TestGraphContext:
def test_none_graph_returns_none(self):
assert _graph_context("성산일출봉", None) is None
@@ -151,6 +158,7 @@ def test_no_nearby_omits_key(self):
# _build_user_prompt
# ---------------------------------------------------------------------------
+
class TestBuildUserPrompt:
def test_contains_plan_info(self):
prompt = _build_user_prompt([], [], {}, {}, None, make_plan(), 80)
@@ -181,7 +189,13 @@ def test_overall_item_present(self):
def test_graph_evidence_included_when_matched(self):
prompt = _build_user_prompt(
- [make_hard_fail()], [], {}, {}, None, make_plan(), 45,
+ [make_hard_fail()],
+ [],
+ {},
+ {},
+ None,
+ make_plan(),
+ 45,
graph=make_graph_stub(),
)
assert "지식그래프_근거" in prompt
@@ -207,7 +221,9 @@ def test_day_index_included_for_warning(self):
assert "경복궁" in prompt
def test_no_day_index_omits_day_field(self):
- prompt = _build_user_prompt([make_hard_fail()], [make_warning()], {}, {}, None, make_plan(), 45)
+ prompt = _build_user_prompt(
+ [make_hard_fail()], [make_warning()], {}, {}, None, make_plan(), 45
+ )
assert "일자" not in prompt.split("출력 예시")[0]
def test_warning_graph_evidence_uses_first_poi_name(self):
@@ -222,56 +238,102 @@ def test_warning_graph_evidence_uses_first_poi_name(self):
# _parse_llm_response
# ---------------------------------------------------------------------------
+
class TestParseLlmResponse:
def test_parses_valid_json_array(self):
- raw = json.dumps([{
- "item_type": "hard_fail",
- "item_key": "OPERATING_HOURS_CONFLICT",
- "fact": "경복궁 도착 18:30, 운영 종료 18:00",
- "rule": "운영시간 외 방문 불가",
- "risk": "CRITICAL",
- "suggestion": "방문 순서를 앞당기세요",
- }])
+ raw = json.dumps(
+ [
+ {
+ "item_type": "hard_fail",
+ "item_key": "OPERATING_HOURS_CONFLICT",
+ "fact": "경복궁 도착 18:30, 운영 종료 18:00",
+ "rule": "운영시간 외 방문 불가",
+ "risk": "CRITICAL",
+ "suggestion": "방문 순서를 앞당기세요",
+ }
+ ]
+ )
items = _parse_llm_response(raw)
assert len(items) == 1
assert items[0].item_type == "hard_fail"
assert items[0].risk == "CRITICAL"
def test_strips_code_block_wrapper(self):
- raw = "```json\n[{\"item_type\":\"overall\",\"item_key\":\"summary\",\"fact\":\"점수 80\",\"rule\":\"규칙\",\"risk\":\"OK\",\"suggestion\":\"좋음\"}]\n```"
+ raw = '```json\n[{"item_type":"overall","item_key":"summary","fact":"점수 80","rule":"규칙","risk":"OK","suggestion":"좋음"}]\n```'
items = _parse_llm_response(raw)
assert len(items) == 1
assert items[0].risk == "OK"
def test_multiple_items(self):
- raw = json.dumps([
- {"item_type": "hard_fail", "item_key": "HF1", "fact": "f", "rule": "r", "risk": "CRITICAL", "suggestion": "s"},
- {"item_type": "warning", "item_key": "W1", "fact": "f", "rule": "r", "risk": "WARNING", "suggestion": "s"},
- ])
+ raw = json.dumps(
+ [
+ {
+ "item_type": "hard_fail",
+ "item_key": "HF1",
+ "fact": "f",
+ "rule": "r",
+ "risk": "CRITICAL",
+ "suggestion": "s",
+ },
+ {
+ "item_type": "warning",
+ "item_key": "W1",
+ "fact": "f",
+ "rule": "r",
+ "risk": "WARNING",
+ "suggestion": "s",
+ },
+ ]
+ )
items = _parse_llm_response(raw)
assert len(items) == 2
def test_returns_explanation_items(self):
- raw = json.dumps([{
- "item_type": "overall", "item_key": "summary",
- "fact": "fact", "rule": "rule", "risk": "OK", "suggestion": "sug",
- }])
+ raw = json.dumps(
+ [
+ {
+ "item_type": "overall",
+ "item_key": "summary",
+ "fact": "fact",
+ "rule": "rule",
+ "risk": "OK",
+ "suggestion": "sug",
+ }
+ ]
+ )
items = _parse_llm_response(raw)
assert all(isinstance(i, ExplanationItem) for i in items)
def test_day_index_echoed_back(self):
- raw = json.dumps([{
- "item_type": "hard_fail", "item_key": "OPERATING_HOURS_CONFLICT", "day_index": 1,
- "fact": "f", "rule": "r", "risk": "CRITICAL", "suggestion": "s",
- }])
+ raw = json.dumps(
+ [
+ {
+ "item_type": "hard_fail",
+ "item_key": "OPERATING_HOURS_CONFLICT",
+ "day_index": 1,
+ "fact": "f",
+ "rule": "r",
+ "risk": "CRITICAL",
+ "suggestion": "s",
+ }
+ ]
+ )
items = _parse_llm_response(raw)
assert items[0].day_index == 1
def test_missing_day_index_defaults_to_none(self):
- raw = json.dumps([{
- "item_type": "overall", "item_key": "summary",
- "fact": "f", "rule": "r", "risk": "OK", "suggestion": "s",
- }])
+ raw = json.dumps(
+ [
+ {
+ "item_type": "overall",
+ "item_key": "summary",
+ "fact": "f",
+ "rule": "r",
+ "risk": "OK",
+ "suggestion": "s",
+ }
+ ]
+ )
items = _parse_llm_response(raw)
assert items[0].day_index is None
@@ -280,6 +342,7 @@ def test_missing_day_index_defaults_to_none(self):
# _fallback
# ---------------------------------------------------------------------------
+
class TestFallback:
def test_hard_fail_becomes_critical(self):
items = _fallback([make_hard_fail()], [], {}, 45)
@@ -348,6 +411,7 @@ def test_no_day_index_no_prefix(self):
# ExplainEngine (no LLM)
# ---------------------------------------------------------------------------
+
class TestExplainEngineNoLLM:
def setup_method(self):
# API 키 없이 인스턴스 — fallback 경로 테스트
@@ -371,8 +435,13 @@ def test_generate_returns_list_of_explanation_items(self):
def test_no_issues_returns_ok_overall(self):
result = self.engine.generate(
- hard_fails=[], warnings=[], penalty_breakdown={},
- bonus_breakdown={}, scores=make_scores(), plan=make_plan(), final_score=82,
+ hard_fails=[],
+ warnings=[],
+ penalty_breakdown={},
+ bonus_breakdown={},
+ scores=make_scores(),
+ plan=make_plan(),
+ final_score=82,
)
assert len(result) == 1
assert result[0].item_type == "overall"
@@ -380,24 +449,39 @@ def test_no_issues_returns_ok_overall(self):
def test_hard_fail_present_in_results(self):
result = self.engine.generate(
- hard_fails=[make_hard_fail()], warnings=[], penalty_breakdown={},
- bonus_breakdown={}, scores=None, plan=make_plan(), final_score=45,
+ hard_fails=[make_hard_fail()],
+ warnings=[],
+ penalty_breakdown={},
+ bonus_breakdown={},
+ scores=None,
+ plan=make_plan(),
+ final_score=45,
)
hf_items = [i for i in result if i.item_type == "hard_fail"]
assert len(hf_items) >= 1
def test_warning_present_in_results(self):
result = self.engine.generate(
- hard_fails=[], warnings=[make_warning()], penalty_breakdown={},
- bonus_breakdown={}, scores=None, plan=make_plan(), final_score=70,
+ hard_fails=[],
+ warnings=[make_warning()],
+ penalty_breakdown={},
+ bonus_breakdown={},
+ scores=None,
+ plan=make_plan(),
+ final_score=70,
)
w_items = [i for i in result if i.item_type == "warning"]
assert len(w_items) >= 1
def test_penalty_present_in_results(self):
result = self.engine.generate(
- hard_fails=[], warnings=[], penalty_breakdown={"cluster_dispersion": 10},
- bonus_breakdown={}, scores=None, plan=make_plan(), final_score=70,
+ hard_fails=[],
+ warnings=[],
+ penalty_breakdown={"cluster_dispersion": 10},
+ bonus_breakdown={},
+ scores=None,
+ plan=make_plan(),
+ final_score=70,
)
p_items = [i for i in result if i.item_type == "penalty"]
assert len(p_items) >= 1
@@ -407,6 +491,7 @@ def test_penalty_present_in_results(self):
# ExplainEngine — LLM mock 경로
# ---------------------------------------------------------------------------
+
class TestExplainEngineMockLLM:
def _make_mock_client(self, response_json: list[dict]):
raw = json.dumps(response_json)
@@ -419,25 +504,33 @@ def _make_mock_client(self, response_json: list[dict]):
return client
def test_llm_response_used_when_available(self):
- llm_output = [{
- "item_type": "hard_fail",
- "item_key": "OPERATING_HOURS_CONFLICT",
- "fact": "경복궁 도착 18:30, 운영종료 18:00 — 30분 초과",
- "rule": "운영시간 외 방문 불가 (Hard Fail)",
- "risk": "CRITICAL",
- "suggestion": "방문 순서를 오전으로 앞당기세요.",
- }, {
- "item_type": "overall",
- "item_key": "summary",
- "fact": "최종 점수 45/100",
- "rule": "60점 미만은 FAIL",
- "risk": "CRITICAL",
- "suggestion": "Hard Fail 해결 후 재검증하세요.",
- }]
+ llm_output = [
+ {
+ "item_type": "hard_fail",
+ "item_key": "OPERATING_HOURS_CONFLICT",
+ "fact": "경복궁 도착 18:30, 운영종료 18:00 — 30분 초과",
+ "rule": "운영시간 외 방문 불가 (Hard Fail)",
+ "risk": "CRITICAL",
+ "suggestion": "방문 순서를 오전으로 앞당기세요.",
+ },
+ {
+ "item_type": "overall",
+ "item_key": "summary",
+ "fact": "최종 점수 45/100",
+ "rule": "60점 미만은 FAIL",
+ "risk": "CRITICAL",
+ "suggestion": "Hard Fail 해결 후 재검증하세요.",
+ },
+ ]
engine = ExplainEngine(api_key="test-key", client=self._make_mock_client(llm_output))
result = engine.generate(
- hard_fails=[make_hard_fail()], warnings=[], penalty_breakdown={},
- bonus_breakdown={}, scores=None, plan=make_plan(), final_score=45,
+ hard_fails=[make_hard_fail()],
+ warnings=[],
+ penalty_breakdown={},
+ bonus_breakdown={},
+ scores=None,
+ plan=make_plan(),
+ final_score=45,
)
assert len(result) == 2
assert result[0].fact == "경복궁 도착 18:30, 운영종료 18:00 — 30분 초과"
@@ -447,20 +540,32 @@ def test_llm_failure_falls_back_gracefully(self):
client.messages.create.side_effect = Exception("API timeout")
engine = ExplainEngine(api_key="test-key", client=client)
result = engine.generate(
- hard_fails=[make_hard_fail()], warnings=[], penalty_breakdown={},
- bonus_breakdown={}, scores=None, plan=make_plan(), final_score=45,
+ hard_fails=[make_hard_fail()],
+ warnings=[],
+ penalty_breakdown={},
+ bonus_breakdown={},
+ scores=None,
+ plan=make_plan(),
+ final_score=45,
)
assert len(result) >= 1
assert all(isinstance(i, ExplanationItem) for i in result)
def test_cache_prevents_second_llm_call(self):
import src.explain.explain_engine as ee
+
ee._CACHE.clear() # 모듈 단위 캐시 초기화 — 타 테스트와 격리
- llm_output = [{
- "item_type": "overall", "item_key": "summary",
- "fact": "f", "rule": "r", "risk": "CRITICAL", "suggestion": "s",
- }]
+ llm_output = [
+ {
+ "item_type": "overall",
+ "item_key": "summary",
+ "fact": "f",
+ "rule": "r",
+ "risk": "CRITICAL",
+ "suggestion": "s",
+ }
+ ]
client = self._make_mock_client(llm_output)
engine = ExplainEngine(api_key="test-key", client=client)
# 동일 입력으로 두 번 호출
@@ -476,17 +581,29 @@ def test_is_available_with_client(self):
def test_graph_evidence_reaches_llm_prompt(self):
import src.explain.explain_engine as ee
+
ee._CACHE.clear()
- llm_output = [{
- "item_type": "hard_fail", "item_key": "OPERATING_HOURS_CONFLICT",
- "fact": "f", "rule": "r", "risk": "CRITICAL", "suggestion": "s",
- }]
+ llm_output = [
+ {
+ "item_type": "hard_fail",
+ "item_key": "OPERATING_HOURS_CONFLICT",
+ "fact": "f",
+ "rule": "r",
+ "risk": "CRITICAL",
+ "suggestion": "s",
+ }
+ ]
client = self._make_mock_client(llm_output)
engine = ExplainEngine(api_key="test-key", client=client, graph_retriever=make_graph_stub())
engine.generate(
- hard_fails=[make_hard_fail()], warnings=[], penalty_breakdown={},
- bonus_breakdown={}, scores=None, plan=make_plan(), final_score=45,
+ hard_fails=[make_hard_fail()],
+ warnings=[],
+ penalty_breakdown={},
+ bonus_breakdown={},
+ scores=None,
+ plan=make_plan(),
+ final_score=45,
)
sent_prompt = client.messages.create.call_args.kwargs["messages"][0]["content"]
assert "지식그래프_근거" in sent_prompt
@@ -494,16 +611,17 @@ def test_graph_evidence_reaches_llm_prompt(self):
class TestExplainEngineGraphDefault:
- def test_default_graph_disabled_without_env(self, monkeypatch):
+ def test_default_graph_uses_local_catalog_without_env(self, monkeypatch):
monkeypatch.delenv("NEO4J_URI", raising=False)
engine = ExplainEngine(api_key="", client=None)
- assert engine._graph.enabled is False
+ assert engine._graph.enabled is True
# ---------------------------------------------------------------------------
# ExplainEngine.build_alternatives — Hard Fail POI 지식그래프 대안 제안
# ---------------------------------------------------------------------------
+
class TestBuildAlternatives:
def test_no_hard_fails_returns_empty(self):
engine = ExplainEngine(api_key="", client=None, graph_retriever=make_graph_stub())
diff --git a/tests/test_geo.py b/tests/test_geo.py
index 4ed7e72..1af5b5c 100644
--- a/tests/test_geo.py
+++ b/tests/test_geo.py
@@ -1,4 +1,5 @@
"""Tests for src/utils/geo.py (TDD)."""
+
from __future__ import annotations
import pytest
@@ -9,9 +10,12 @@
def make_poi(poi_id: str, lat: float, lng: float) -> POI:
return POI(
- poi_id=poi_id, name=poi_id,
- lat=lat, lng=lng,
- open_start="09:00", open_end="18:00",
+ poi_id=poi_id,
+ name=poi_id,
+ lat=lat,
+ lng=lng,
+ open_start="09:00",
+ open_end="18:00",
duration_min=60,
)
@@ -20,6 +24,7 @@ def make_poi(poi_id: str, lat: float, lng: float) -> POI:
# haversine_km
# ---------------------------------------------------------------------------
+
class TestHaversineKm:
def test_same_point_is_zero(self):
assert haversine_km(37.5, 127.0, 37.5, 127.0) == pytest.approx(0.0, abs=1e-9)
@@ -42,6 +47,7 @@ def test_positive(self):
# build_dist_cache
# ---------------------------------------------------------------------------
+
class TestBuildDistCache:
def test_all_pairs_present(self):
pois = [make_poi(str(i), 37.5 + i * 0.1, 127.0) for i in range(4)]
@@ -80,6 +86,7 @@ def test_empty_list_empty_cache(self):
# nn_heuristic_km
# ---------------------------------------------------------------------------
+
class TestNnHeuristicKm:
def test_single_poi_returns_zero(self):
pois = [make_poi("A", 37.5, 127.0)]
@@ -115,8 +122,7 @@ def test_collinear_optimal_order_matches_nn(self):
# 일렬로 나열된 POI를 순서대로 방문 → NN과 동일
pois = [make_poi(str(i), 37.5, 127.0 + i * 0.1) for i in range(4)]
actual_km = sum(
- haversine_km(37.5, 127.0 + i * 0.1, 37.5, 127.0 + (i + 1) * 0.1)
- for i in range(3)
+ haversine_km(37.5, 127.0 + i * 0.1, 37.5, 127.0 + (i + 1) * 0.1) for i in range(3)
)
assert nn_heuristic_km(pois) == pytest.approx(actual_km, rel=1e-6)
@@ -125,6 +131,7 @@ def test_collinear_optimal_order_matches_nn(self):
# get_travel_min
# ---------------------------------------------------------------------------
+
class TestGetTravelMin:
def test_uses_matrix_when_available(self):
origin = make_poi("A", 37.5, 127.0)
diff --git a/tests/test_graph_retriever.py b/tests/test_graph_retriever.py
index 0bda011..5bf2737 100644
--- a/tests/test_graph_retriever.py
+++ b/tests/test_graph_retriever.py
@@ -1,97 +1,41 @@
-"""GraphRetriever 테스트 (실제 Neo4j 호출 X — 모두 mock)."""
-from __future__ import annotations
+"""로컬 장소 근거 리트리버 테스트."""
-from unittest.mock import MagicMock, patch
+from pathlib import Path
-from neo4j.exceptions import Neo4jError
-
-from src.data.graph_retriever import GraphRetriever
+from src.data.evidence_retriever import LocalEvidenceRetriever
from src.data.models import AlternativePOI, PlaceEvidence
-def test_disabled_without_uri_returns_empty() -> None:
- retriever = GraphRetriever(uri="", username="", password="")
+def _catalog(tmp_path: Path) -> Path:
+ path = tmp_path / "places.csv"
+ path.write_text(
+ "ID,대분류,상호명,도로명주소,위도,경도,중분류명\n"
+ "1,관광지,성산일출봉,제주특별자치도 서귀포시 성산읍,33.458,126.942,자연관광지\n"
+ "2,관광지,섭지코지,제주특별자치도 서귀포시 성산읍,33.43,126.93,자연관광지\n",
+ encoding="utf-8",
+ )
+ return path
+
+
+def test_missing_catalog_is_disabled(tmp_path: Path) -> None:
+ retriever = LocalEvidenceRetriever(tmp_path / "missing.csv")
assert retriever.enabled is False
assert retriever.search_places("성산일출봉") == []
- assert retriever.find_nearby("kakao_1") == []
-
-def test_search_places_parses_records() -> None:
- with patch("src.data.graph_retriever.GraphDatabase.driver", return_value=MagicMock()):
- retriever = GraphRetriever(uri="neo4j+s://x", username="u", password="p", database="db")
- fake_result = MagicMock()
- fake_result.records = [
- {
- "id": "kakao_1", "name": "성산일출봉", "place_type": "ACTIVITY",
- "category_name": "자연관광지", "address": "제주 서귀포시 ...",
- "lat": 33.458, "lng": 126.942, "region_name": "성산읍",
- }
- ]
- retriever._driver.execute_query.return_value = fake_result
- places = retriever.search_places("일출봉")
+def test_search_places_reads_local_catalog(tmp_path: Path) -> None:
+ retriever = LocalEvidenceRetriever(_catalog(tmp_path))
+ places = retriever.search_places("일출봉")
assert len(places) == 1
assert isinstance(places[0], PlaceEvidence)
assert places[0].name == "성산일출봉"
- assert places[0].region_name == "성산읍"
-
-
-def test_search_places_empty_query_skips_call() -> None:
- with patch("src.data.graph_retriever.GraphDatabase.driver", return_value=MagicMock()):
- retriever = GraphRetriever(uri="neo4j+s://x", username="u", password="p")
- assert retriever.search_places(" ") == []
- retriever._driver.execute_query.assert_not_called()
-
-
-def test_search_places_neo4j_error_returns_empty() -> None:
- with patch("src.data.graph_retriever.GraphDatabase.driver", return_value=MagicMock()):
- retriever = GraphRetriever(uri="neo4j+s://x", username="u", password="p")
- retriever._driver.execute_query.side_effect = Neo4jError("boom")
- assert retriever.search_places("일출봉") == []
-
+ assert places[0].region_name == "제주특별자치도 서귀포시"
-def test_find_nearby_parses_and_converts_distance() -> None:
- with patch("src.data.graph_retriever.GraphDatabase.driver", return_value=MagicMock()):
- retriever = GraphRetriever(uri="neo4j+s://x", username="u", password="p")
- fake_result = MagicMock()
- fake_result.records = [
- {"name": "우도", "category": "자연관광지", "lat": 33.5, "lng": 126.95, "distance_m": 250.0},
- ]
- retriever._driver.execute_query.return_value = fake_result
- alts = retriever.find_nearby("kakao_1")
- assert len(alts) == 1
- assert isinstance(alts[0], AlternativePOI)
- assert alts[0].distance_km == 0.25
-
-
-def test_repeated_failures_skip_driver_call_during_cooldown() -> None:
- with patch("src.data.graph_retriever.GraphDatabase.driver", return_value=MagicMock()):
- retriever = GraphRetriever(uri="neo4j+s://x", username="u", password="p")
- retriever._driver.execute_query.side_effect = Neo4jError("boom")
-
- assert retriever.search_places("일출봉") == []
- assert retriever.find_nearby("kakao_1") == []
-
- assert retriever._driver.execute_query.call_count == 1
-
-
-def test_close_closes_driver() -> None:
- with patch("src.data.graph_retriever.GraphDatabase.driver", return_value=MagicMock()):
- retriever = GraphRetriever(uri="neo4j+s://x", username="u", password="p")
- retriever.close()
- retriever._driver.close.assert_called_once()
-
-
-def test_from_env_reads_variables(monkeypatch) -> None:
- monkeypatch.setenv("NEO4J_URI", "neo4j+s://x")
- monkeypatch.setenv("NEO4J_USERNAME", "u")
- monkeypatch.setenv("NEO4J_PASSWORD", "p")
- monkeypatch.setenv("NEO4J_DATABASE", "db")
- with patch("src.data.graph_retriever.GraphDatabase.driver", return_value=MagicMock()) as create:
- retriever = GraphRetriever.from_env()
-
- create.assert_called_once_with(
- "neo4j+s://x", auth=("u", "p"), connection_timeout=5.0, max_transaction_retry_time=5.0
- )
- assert retriever._database == "db"
+def test_find_nearby_returns_local_alternatives(tmp_path: Path) -> None:
+ retriever = LocalEvidenceRetriever(_catalog(tmp_path))
+ alternatives = retriever.find_nearby("1")
+ assert len(alternatives) == 1
+ assert isinstance(alternatives[0], AlternativePOI)
+ assert alternatives[0].name == "섭지코지"
+ assert alternatives[0].distance_km > 0
diff --git a/tests/test_hard_fail.py b/tests/test_hard_fail.py
index 5f96c7f..7775353 100644
--- a/tests/test_hard_fail.py
+++ b/tests/test_hard_fail.py
@@ -1,4 +1,5 @@
"""Tests for HardFailDetector (TDD)."""
+
from __future__ import annotations
import pytest
@@ -10,6 +11,7 @@
# Helpers
# ---------------------------------------------------------------------------
+
def make_poi(
poi_id: str = "1",
name: str = "POI",
@@ -21,9 +23,14 @@ def make_poi(
category: str = "14",
) -> POI:
return POI(
- poi_id=poi_id, name=name, lat=lat, lng=lng,
- open_start=open_start, open_end=open_end,
- duration_min=duration_min, category=category,
+ poi_id=poi_id,
+ name=name,
+ lat=lat,
+ lng=lng,
+ open_start=open_start,
+ open_end=open_end,
+ duration_min=duration_min,
+ category=category,
)
@@ -54,6 +61,7 @@ def make_matrix(pairs: dict[tuple[int, int], float]) -> dict:
# Fixtures
# ---------------------------------------------------------------------------
+
@pytest.fixture
def detector() -> HardFailDetector:
return HardFailDetector()
@@ -68,6 +76,7 @@ def open_poi() -> POI:
# _time_to_min / _min_to_time
# ---------------------------------------------------------------------------
+
class TestHelpers:
def test_time_to_min(self):
assert HardFailDetector._time_to_min("09:30") == 570
@@ -89,6 +98,7 @@ def test_min_to_time_wraps_past_24h(self):
# OPERATING_HOURS_CONFLICT
# ---------------------------------------------------------------------------
+
class TestOperatingHours:
def test_no_fail_within_hours(self, detector, open_poi):
# start=09:10, open 09:00-18:00 → no fail
@@ -98,6 +108,20 @@ def test_no_fail_within_hours(self, detector, open_poi):
types = [f.fail_type for f in fails]
assert "OPERATING_HOURS_CONFLICT" not in types
+ def test_stay_must_finish_before_closing(self, detector):
+ poi = make_poi(
+ poi_id="1",
+ name="A",
+ open_start="10:00",
+ open_end="11:00",
+ duration_min=120,
+ )
+ plan = make_plan(["A"])
+
+ fails = detector.detect(plan, [poi], {}, start_minutes=10 * 60 + 30)
+
+ assert any(f.fail_type == "OPERATING_HOURS_CONFLICT" for f in fails)
+
def test_fail_arrive_before_open(self, detector, open_poi):
# start=08:30, open 09:00-18:00 → OPERATING_HOURS_CONFLICT
pois = [open_poi]
@@ -132,12 +156,15 @@ def test_no_fail_for_fallback_hours(self, detector):
# TRAVEL_TIME_IMPOSSIBLE
# ---------------------------------------------------------------------------
+
class TestTravelTimeImpossible:
def test_travel_impossible(self, detector):
# departure at 09:00, next poi closes at 10:00 → window=60 min
# matrix says 200 min travel → TRAVEL_TIME_IMPOSSIBLE
poi_a = make_poi(poi_id="1", name="A", open_start="09:00", open_end="18:00", duration_min=1)
- poi_b = make_poi(poi_id="2", name="B", open_start="09:00", open_end="10:00", duration_min=60)
+ poi_b = make_poi(
+ poi_id="2", name="B", open_start="09:00", open_end="10:00", duration_min=60
+ )
pois = [poi_a, poi_b]
matrix = make_matrix({(0, 1): 200.0}) # 200 min travel
plan = make_plan(["A", "B"])
@@ -148,8 +175,12 @@ def test_travel_impossible(self, detector):
assert match.confidence == "High"
def test_no_fail_sufficient_window(self, detector):
- poi_a = make_poi(poi_id="1", name="A", open_start="09:00", open_end="18:00", duration_min=60)
- poi_b = make_poi(poi_id="2", name="B", open_start="09:00", open_end="18:00", duration_min=60)
+ poi_a = make_poi(
+ poi_id="1", name="A", open_start="09:00", open_end="18:00", duration_min=60
+ )
+ poi_b = make_poi(
+ poi_id="2", name="B", open_start="09:00", open_end="18:00", duration_min=60
+ )
pois = [poi_a, poi_b]
matrix = make_matrix({(0, 1): 30.0})
plan = make_plan(["A", "B"])
@@ -162,19 +193,22 @@ def test_no_fail_sufficient_window(self, detector):
# SCHEDULE_INFEASIBLE
# ---------------------------------------------------------------------------
+
class TestScheduleInfeasible:
def test_schedule_exceeds_24h(self, detector):
# 4 POIs × 360 min dwell + heavy travel → > 1440 min
pois = [
- make_poi(poi_id=str(i), name=f"P{i}",
- lat=37.5 + i * 0.01, lng=127.0,
- duration_min=360)
+ make_poi(poi_id=str(i), name=f"P{i}", lat=37.5 + i * 0.01, lng=127.0, duration_min=360)
for i in range(4)
]
# travel 30 min between each pair
- matrix = make_matrix({
- (0, 1): 30.0, (1, 2): 30.0, (2, 3): 30.0,
- })
+ matrix = make_matrix(
+ {
+ (0, 1): 30.0,
+ (1, 2): 30.0,
+ (2, 3): 30.0,
+ }
+ )
plan = make_plan([f"P{i}" for i in range(4)])
fails = detector.detect(plan, pois, matrix)
# 4×360 + 3×30 = 1440 + 90 = 1530 > 1440
@@ -182,10 +216,7 @@ def test_schedule_exceeds_24h(self, detector):
assert "SCHEDULE_INFEASIBLE" in types
def test_schedule_within_24h(self, detector):
- pois = [
- make_poi(poi_id=str(i), name=f"P{i}", duration_min=60)
- for i in range(4)
- ]
+ pois = [make_poi(poi_id=str(i), name=f"P{i}", duration_min=60) for i in range(4)]
matrix = make_matrix({(0, 1): 30.0, (1, 2): 30.0, (2, 3): 30.0})
plan = make_plan([f"P{i}" for i in range(4)])
fails = detector.detect(plan, pois, matrix)
@@ -198,6 +229,7 @@ def test_schedule_within_24h(self, detector):
# Normal plan — empty result
# ---------------------------------------------------------------------------
+
class TestNormalPlan:
def test_normal_plan_no_fails(self, detector):
pois = [
@@ -206,9 +238,13 @@ def test_normal_plan_no_fails(self, detector):
make_poi(poi_id="3", name="C", open_start="09:00", open_end="18:00", duration_min=60),
make_poi(poi_id="4", name="D", open_start="09:00", open_end="18:00", duration_min=60),
]
- matrix = make_matrix({
- (0, 1): 20.0, (1, 2): 20.0, (2, 3): 20.0,
- })
+ matrix = make_matrix(
+ {
+ (0, 1): 20.0,
+ (1, 2): 20.0,
+ (2, 3): 20.0,
+ }
+ )
plan = make_plan(["A", "B", "C", "D"])
fails = detector.detect(plan, pois, matrix)
assert fails == []
@@ -218,6 +254,7 @@ def test_normal_plan_no_fails(self, detector):
# day_index threading
# ---------------------------------------------------------------------------
+
class TestDayIndex:
def test_day_index_defaults_to_none(self, detector):
poi = make_poi(poi_id="1", name="A", open_start="09:00", open_end="18:00", duration_min=60)
diff --git a/tests/test_kakao_local.py b/tests/test_kakao_local.py
index 667bfd6..44f1480 100644
--- a/tests/test_kakao_local.py
+++ b/tests/test_kakao_local.py
@@ -1,4 +1,5 @@
"""KakaoLocalClient 테스트 (실제 API 호출 X — 모두 mock)."""
+
from __future__ import annotations
from unittest.mock import MagicMock, patch
@@ -75,10 +76,20 @@ def _multi_response() -> MagicMock:
m.raise_for_status.return_value = None
m.json.return_value = {
"documents": [
- {"place_name": "금복식당", "x": "126.922", "y": "37.547",
- "category_name": "음식점 > 한식", "road_address_name": "서울 마포구 ..."},
- {"place_name": "금복식당 2호점", "x": "126.923", "y": "37.548",
- "category_name": "음식점 > 한식", "address_name": "서울 마포구 ..."},
+ {
+ "place_name": "금복식당",
+ "x": "126.922",
+ "y": "37.547",
+ "category_name": "음식점 > 한식",
+ "road_address_name": "서울 마포구 ...",
+ },
+ {
+ "place_name": "금복식당 2호점",
+ "x": "126.923",
+ "y": "37.548",
+ "category_name": "음식점 > 한식",
+ "address_name": "서울 마포구 ...",
+ },
]
}
return m
diff --git a/tests/test_kakao_matrix.py b/tests/test_kakao_matrix.py
index 8ab2256..1497900 100644
--- a/tests/test_kakao_matrix.py
+++ b/tests/test_kakao_matrix.py
@@ -1,4 +1,5 @@
"""KakaoMobilityMatrix 테스트 (실제 API 호출 X — 모두 mock)."""
+
from __future__ import annotations
import json
@@ -12,8 +13,13 @@
def _place(name: str, lng: float, lat: float) -> VRPTWPlace:
return VRPTWPlace(
- name=name, lng=lng, lat=lat,
- open="09:00", close="22:00", stay_duration=60, is_depot=False,
+ name=name,
+ lng=lng,
+ lat=lat,
+ open="09:00",
+ close="22:00",
+ stay_duration=60,
+ is_depot=False,
)
@@ -22,10 +28,12 @@ def _ok_response() -> MagicMock:
m = MagicMock()
m.status_code = 200
m.json.return_value = {
- "routes": [{
- "summary": {"duration": 600, "distance": 5000},
- "sections": [{"duration": 600}],
- }],
+ "routes": [
+ {
+ "summary": {"duration": 600, "distance": 5000},
+ "sections": [{"duration": 600}],
+ }
+ ],
}
return m
@@ -44,6 +52,7 @@ def _httpx_sync_client(response: MagicMock) -> MagicMock:
# Same point → zero
# ---------------------------------------------------------------------------
+
class TestSamePoint:
def test_same_coords_returns_zero(self):
m = KakaoMobilityMatrix(api_key="dummy")
@@ -55,14 +64,17 @@ def test_same_coords_returns_zero(self):
# Cache + sync API (_call_kakao_sync)
# ---------------------------------------------------------------------------
+
class TestApiCall:
def test_sync_call_populates_cache(self):
m = KakaoMobilityMatrix(api_key="dummy")
a = _place("A", 127.0, 37.5)
b = _place("B", 127.1, 37.6)
- with patch("src.validation.kakao_matrix.httpx.Client",
- return_value=_httpx_sync_client(_ok_response())):
+ with patch(
+ "src.validation.kakao_matrix.httpx.Client",
+ return_value=_httpx_sync_client(_ok_response()),
+ ):
result = m._call_kakao_sync(a, b)
assert result == 600
@@ -73,8 +85,10 @@ def test_get_travel_time_uses_cache_after_sync_call(self):
a = _place("A", 127.0, 37.5)
b = _place("B", 127.1, 37.6)
- with patch("src.validation.kakao_matrix.httpx.Client",
- return_value=_httpx_sync_client(_ok_response())):
+ with patch(
+ "src.validation.kakao_matrix.httpx.Client",
+ return_value=_httpx_sync_client(_ok_response()),
+ ):
m._call_kakao_sync(a, b)
result = m.get_travel_time(a, b)
@@ -87,12 +101,14 @@ def test_get_travel_time_second_call_cache_hit(self):
a = _place("A", 127.0, 37.5)
b = _place("B", 127.1, 37.6)
- with patch("src.validation.kakao_matrix.httpx.Client",
- return_value=_httpx_sync_client(_ok_response())):
+ with patch(
+ "src.validation.kakao_matrix.httpx.Client",
+ return_value=_httpx_sync_client(_ok_response()),
+ ):
m._call_kakao_sync(a, b)
- m.get_travel_time(a, b) # 1st hit
- m.get_travel_time(a, b) # 2nd hit
+ m.get_travel_time(a, b) # 1st hit
+ m.get_travel_time(a, b) # 2nd hit
assert m.stats["cache_hit"] == 2
def test_reverse_direction_also_cached(self):
@@ -100,8 +116,10 @@ def test_reverse_direction_also_cached(self):
a = _place("A", 127.0, 37.5)
b = _place("B", 127.1, 37.6)
- with patch("src.validation.kakao_matrix.httpx.Client",
- return_value=_httpx_sync_client(_ok_response())):
+ with patch(
+ "src.validation.kakao_matrix.httpx.Client",
+ return_value=_httpx_sync_client(_ok_response()),
+ ):
m._call_kakao_sync(a, b)
result = m.get_travel_time(b, a) # reverse 방향
@@ -113,6 +131,7 @@ def test_reverse_direction_also_cached(self):
# Quota exhaustion — 429
# ---------------------------------------------------------------------------
+
class TestQuotaExhaustion:
def test_429_sets_quota_exhausted(self):
m = KakaoMobilityMatrix(api_key="dummy")
@@ -122,8 +141,9 @@ def test_429_sets_quota_exhausted(self):
resp_429 = MagicMock()
resp_429.status_code = 429
- with patch("src.validation.kakao_matrix.httpx.Client",
- return_value=_httpx_sync_client(resp_429)):
+ with patch(
+ "src.validation.kakao_matrix.httpx.Client", return_value=_httpx_sync_client(resp_429)
+ ):
result = m._call_kakao_sync(a, b)
assert result is None
@@ -134,7 +154,7 @@ def test_get_travel_time_haversine_fallback_when_no_cache(self):
a = _place("A", 127.0, 37.5)
b = _place("B", 127.1, 37.6)
- result = m.get_travel_time(a, b) # cache miss → haversine
+ result = m.get_travel_time(a, b) # cache miss → haversine
assert result > 0
assert m.stats["fallback"] == 1
@@ -152,6 +172,7 @@ def test_after_quota_exhausted_get_travel_time_falls_back(self):
# Auth error
# ---------------------------------------------------------------------------
+
class TestAuthError:
def test_401_raises(self):
resp_401 = MagicMock()
@@ -161,8 +182,9 @@ def test_401_raises(self):
a = _place("A", 127.0, 37.5)
b = _place("B", 127.1, 37.6)
- with patch("src.validation.kakao_matrix.httpx.Client",
- return_value=_httpx_sync_client(resp_401)):
+ with patch(
+ "src.validation.kakao_matrix.httpx.Client", return_value=_httpx_sync_client(resp_401)
+ ):
with pytest.raises(RuntimeError, match="인증 오류"):
m._call_kakao_sync(a, b)
@@ -171,6 +193,7 @@ def test_401_raises(self):
# Cache persistence
# ---------------------------------------------------------------------------
+
class TestCachePersistence:
def test_save_and_load_cache(self, tmp_path):
cache_file = tmp_path / "route_cache.json"
@@ -179,8 +202,10 @@ def test_save_and_load_cache(self, tmp_path):
a = _place("A", 127.0, 37.5)
b = _place("B", 127.1, 37.6)
- with patch("src.validation.kakao_matrix.httpx.Client",
- return_value=_httpx_sync_client(_ok_response())):
+ with patch(
+ "src.validation.kakao_matrix.httpx.Client",
+ return_value=_httpx_sync_client(_ok_response()),
+ ):
m1._call_kakao_sync(a, b)
m1.save_cache()
@@ -198,6 +223,7 @@ def test_save_and_load_cache(self, tmp_path):
# from_env
# ---------------------------------------------------------------------------
+
class TestFromEnv:
def test_no_key_raises(self, monkeypatch):
monkeypatch.delenv("KAKAO_MOBILITY_KEY", raising=False)
@@ -222,10 +248,10 @@ def test_falls_back_to_rest_key(self, monkeypatch):
# aprefetch_matrix (async)
# ---------------------------------------------------------------------------
+
class TestAsyncPrefetch:
def test_aprefetch_populates_cache_and_hit_on_get(self):
"""aprefetch_matrix 후 get_travel_time이 캐시를 사용한다."""
- import asyncio
m = KakaoMobilityMatrix(api_key="dummy")
a = _place("A", 127.0, 37.5)
diff --git a/tests/test_party_config.py b/tests/test_party_config.py
index 4da4891..2dcb404 100644
--- a/tests/test_party_config.py
+++ b/tests/test_party_config.py
@@ -1,9 +1,12 @@
"""PartyProfile 수량화 로직 테스트."""
+
from __future__ import annotations
+from dataclasses import FrozenInstanceError
+
import pytest
-from src.data.party_config import PARTY_PROFILES, PartyProfile, get_party_profile
+from src.data.party_config import PARTY_PROFILES, get_party_profile
class TestPartyProfiles:
@@ -43,7 +46,7 @@ def test_unknown_type_returns_default(self):
def test_profile_is_frozen(self):
profile = get_party_profile("친구")
- with pytest.raises(Exception):
+ with pytest.raises(FrozenInstanceError):
profile.speed_factor = 2.0 # type: ignore[misc]
diff --git a/tests/test_pipeline_orchestrator.py b/tests/test_pipeline_orchestrator.py
index 641812a..cce9e5b 100644
--- a/tests/test_pipeline_orchestrator.py
+++ b/tests/test_pipeline_orchestrator.py
@@ -1,19 +1,27 @@
"""Tests for ValidatorPipeline (TDD)."""
+
from __future__ import annotations
from unittest.mock import MagicMock
import pytest
-from src.data.models import AlternativePOI, DayPlan, HardFail, ItineraryPlan, PlaceInput, POI, ValidationResult
+from src.data.models import (
+ POI,
+ AlternativePOI,
+ DayPlan,
+ ItineraryPlan,
+ PlaceInput,
+ ValidationResult,
+)
from src.explain.pipeline import ValidatorPipeline, _to_vrptw_day
from src.scoring.bonus_engine import BonusEngine, _PlaceCoord
-
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
+
def make_poi(
poi_id: str = "1",
lat: float = 37.5,
@@ -22,9 +30,12 @@ def make_poi(
duration_min: int = 60,
) -> POI:
return POI(
- poi_id=poi_id, name=f"POI_{poi_id}",
- lat=lat, lng=lng,
- open_start="09:00", open_end="18:00",
+ poi_id=poi_id,
+ name=f"POI_{poi_id}",
+ lat=lat,
+ lng=lng,
+ open_start="09:00",
+ open_end="18:00",
duration_min=duration_min,
category=category,
)
@@ -81,6 +92,7 @@ def sample_plan(sample_pois: list[POI]) -> ItineraryPlan:
# _to_vrptw_day helper
# ---------------------------------------------------------------------------
+
class TestToVrptwDay:
def test_converts_poi_fields(self):
pois = [make_poi("1", 37.5, 127.0)]
@@ -101,6 +113,7 @@ def test_is_depot_false(self):
# ValidatorPipeline.run() — basic contract
# ---------------------------------------------------------------------------
+
class TestPipelineBasic:
def test_returns_validation_result(self, pipeline, sample_pois, sample_plan):
result = pipeline.run(
@@ -153,15 +166,20 @@ def test_base_score_populated(self, pipeline, sample_pois, sample_plan):
# ValidatorPipeline.run() — hard_fail cap
# ---------------------------------------------------------------------------
+
class TestPipelineHardFail:
def test_open_hours_conflict_caps_score(self, pipeline):
# POI with impossible time window — close < open
pois = [
POI(
- poi_id="X", name="NightOnly",
- lat=37.5, lng=127.0,
- open_start="22:00", open_end="23:00",
- duration_min=60, category="14",
+ poi_id="X",
+ name="NightOnly",
+ lat=37.5,
+ lng=127.0,
+ open_start="22:00",
+ open_end="23:00",
+ duration_min=60,
+ category="14",
),
make_poi("2", 37.51, 127.01),
]
@@ -182,10 +200,14 @@ def test_hard_fail_day_index_matches_offending_day(self, pipeline):
# Day 0 정상, Day 1에 시간대 충돌 POI 배치
day0 = [make_poi("1", 37.50, 127.00)]
night_only = POI(
- poi_id="X", name="NightOnly",
- lat=37.5, lng=127.0,
- open_start="22:00", open_end="23:00",
- duration_min=60, category="14",
+ poi_id="X",
+ name="NightOnly",
+ lat=37.5,
+ lng=127.0,
+ open_start="22:00",
+ open_end="23:00",
+ duration_min=60,
+ category="14",
)
day1 = [night_only]
plan = make_multi_day_plan([[p.name for p in day0], [night_only.name]])
@@ -197,14 +219,22 @@ def test_alternatives_populated_from_explain_engine(self):
mock_explain = MagicMock()
mock_explain.generate.return_value = []
mock_explain.build_alternatives.return_value = {
- "NightOnly": [AlternativePOI(name="Alt", distance_km=0.3, category="14", lat=37.5, lng=127.0)]
+ "NightOnly": [
+ AlternativePOI(name="Alt", distance_km=0.3, category="14", lat=37.5, lng=127.0)
+ ]
}
pipeline = ValidatorPipeline(
bonus_engine=make_empty_bonus_engine(), explain_engine=mock_explain
)
night_only = POI(
- poi_id="X", name="NightOnly", lat=37.5, lng=127.0,
- open_start="22:00", open_end="23:00", duration_min=60, category="14",
+ poi_id="X",
+ name="NightOnly",
+ lat=37.5,
+ lng=127.0,
+ open_start="22:00",
+ open_end="23:00",
+ duration_min=60,
+ category="14",
)
plan = make_plan([night_only.name])
result = pipeline.run(plan=plan, per_day_pois=[[night_only]], matrix={})
@@ -222,6 +252,7 @@ def test_alternatives_not_computed_without_hard_fails(self, pipeline, sample_poi
# ValidatorPipeline.run() — penalty/bonus breakdown
# ---------------------------------------------------------------------------
+
class TestPipelineBreakdown:
def test_breakdown_fields_are_dicts(self, pipeline, sample_pois, sample_plan):
result = pipeline.run(
@@ -257,9 +288,7 @@ def test_accessibility_bonus_for_accessible_party(self):
def test_pet_friendly_bonus_when_enabled(self, pipeline):
poi = make_poi("1", 37.5, 127.0).model_copy(update={"pet_friendly": True})
plan = make_plan([poi.name])
- result = pipeline.run(
- plan=plan, per_day_pois=[[poi]], matrix={}, pet_friendly_enabled=True
- )
+ result = pipeline.run(plan=plan, per_day_pois=[[poi]], matrix={}, pet_friendly_enabled=True)
assert "pet_friendly" in result.bonus_breakdown
assert result.bonus_breakdown["pet_friendly"] > 0
@@ -286,14 +315,17 @@ def test_wellness_matched_exposed_on_result(self):
# ValidatorPipeline.run() — multi-day
# ---------------------------------------------------------------------------
+
class TestPipelineMultiDay:
def test_multi_day_runs_without_error(self, pipeline):
day1 = [make_poi("1", 37.50, 127.00), make_poi("2", 37.51, 127.01)]
day2 = [make_poi("3", 37.52, 127.02), make_poi("4", 37.53, 127.03)]
- plan = make_multi_day_plan([
- [p.name for p in day1],
- [p.name for p in day2],
- ])
+ plan = make_multi_day_plan(
+ [
+ [p.name for p in day1],
+ [p.name for p in day2],
+ ]
+ )
result = pipeline.run(plan=plan, per_day_pois=[day1, day2], matrix={})
assert isinstance(result, ValidationResult)
assert 0 <= result.final_score <= 100
@@ -315,6 +347,7 @@ def test_sigungu_codes_accepted(self, pipeline):
# ValidatorPipeline.run() — VRPTW 통합
# ---------------------------------------------------------------------------
+
class TestPipelineVRPTW:
def test_vrptw_fields_present(self, pipeline, sample_pois, sample_plan):
result = pipeline.run(
@@ -346,10 +379,12 @@ def test_vrptw_efficiency_gap_non_negative(self, pipeline, sample_pois, sample_p
def test_vrptw_optimal_route_per_day_count(self, pipeline):
day1 = [make_poi("1", 37.50, 127.00), make_poi("2", 37.52, 127.02)]
day2 = [make_poi("3", 37.51, 127.01), make_poi("4", 37.53, 127.03)]
- plan = make_multi_day_plan([
- [p.name for p in day1],
- [p.name for p in day2],
- ])
+ plan = make_multi_day_plan(
+ [
+ [p.name for p in day1],
+ [p.name for p in day2],
+ ]
+ )
result = pipeline.run(plan=plan, per_day_pois=[day1, day2], matrix={})
if result.vrptw_optimal_route is not None:
assert len(result.vrptw_optimal_route) == 2
@@ -382,14 +417,21 @@ def test_vrptw_penalty_does_not_double_count_with_single_poi(self, pipeline):
# ValidatorPipeline.run() — Repair 제안 예상 점수 변화 (지도 UX 개선)
# ---------------------------------------------------------------------------
+
class TestPipelineRepairGainEstimation:
def test_deletion_suggestion_carries_gain_and_resolves_flag(self, pipeline):
"""지리적 이상치이자 Hard Fail 유발 POI를 삭제하면 점수가 오르고 문제가 해소돼야 한다."""
a = make_poi("A", 37.50, 127.00)
b = make_poi("B", 37.51, 127.01)
night_only = POI(
- poi_id="X", name="NightOnly", lat=38.50, lng=127.00,
- open_start="22:00", open_end="23:00", duration_min=60, category="14",
+ poi_id="X",
+ name="NightOnly",
+ lat=38.50,
+ lng=127.00,
+ open_start="22:00",
+ open_end="23:00",
+ duration_min=60,
+ category="14",
)
pois = [a, b, night_only]
plan = make_plan([p.name for p in pois])
diff --git a/tests/test_plan_extractor.py b/tests/test_plan_extractor.py
index 9f19cd1..4283fc8 100644
--- a/tests/test_plan_extractor.py
+++ b/tests/test_plan_extractor.py
@@ -1,4 +1,5 @@
"""PlanExtractor 테스트 (실제 Claude API 호출 X — 모두 mock)."""
+
from __future__ import annotations
from unittest.mock import MagicMock
@@ -47,10 +48,14 @@ def test_extract_from_text_empty_raises() -> None:
def test_extract_from_text_without_client_falls_back_to_heuristic() -> None:
extractor = PlanExtractor(client=None, api_key="")
- resp = extractor.extract_from_text("Day 1\n1 다려도 여행지\n2 바람벽에흰당나귀 카페\n\nDay 2\n월정리해변")
+ resp = extractor.extract_from_text(
+ "Day 1\n1 다려도 여행지\n2 바람벽에흰당나귀 카페\n\nDay 2\n월정리해변"
+ )
assert [p.name for d in resp.days for p in d.places] == [
- "다려도", "바람벽에흰당나귀", "월정리해변",
+ "다려도",
+ "바람벽에흰당나귀",
+ "월정리해변",
]
assert len(resp.days) == 2
@@ -101,3 +106,14 @@ def test_api_call_failure_raises_extraction_error() -> None:
with pytest.raises(PlanExtractionError):
extractor.extract_from_text("아무 텍스트")
+
+
+def test_system_prompt_uses_prompt_caching() -> None:
+ """system 프롬프트는 매 호출 동일하므로 ephemeral 캐싱 대상이어야 함(지연/토큰 절감)."""
+ client = _client_returning('{"days":[]}')
+ extractor = PlanExtractor(client=client)
+
+ extractor.extract_from_text("아무 텍스트")
+
+ system = client.messages.create.call_args.kwargs["system"]
+ assert system[0]["cache_control"] == {"type": "ephemeral"}
diff --git a/tests/test_region_config.py b/tests/test_region_config.py
index a999c32..39be36b 100644
--- a/tests/test_region_config.py
+++ b/tests/test_region_config.py
@@ -1,4 +1,5 @@
"""RegionThresholds 유닛 테스트."""
+
from __future__ import annotations
from src.data.region_config import (
diff --git a/tests/test_repair.py b/tests/test_repair.py
index ef2b0d0..cff2ef3 100644
--- a/tests/test_repair.py
+++ b/tests/test_repair.py
@@ -1,8 +1,10 @@
"""RepairEngine 유닛 테스트."""
+
from __future__ import annotations
from src.data.models import POI, DayPlan, HardFail, ItineraryPlan, PlaceInput
from src.data.restaurant_catalog import RestaurantCatalog
+from src.explain.repair import DeletionSuggestion, RepairResult
from src.explain.repair import RepairEngine as _RepairEngineClass
@@ -21,9 +23,14 @@ def _poi(
open_end: str = "18:00",
) -> POI:
return POI(
- poi_id=name, name=name, lat=lat, lng=lng,
- open_start=open_start, open_end=open_end,
- duration_min=duration, category=category,
+ poi_id=name,
+ name=name,
+ lat=lat,
+ lng=lng,
+ open_start=open_start,
+ open_end=open_end,
+ duration_min=duration,
+ category=category,
)
@@ -41,7 +48,9 @@ def _plan(names: list[str], party_type: str = "친구") -> ItineraryPlan:
def _fail() -> HardFail:
return HardFail(
fail_type="SCHEDULE_INFEASIBLE",
- message="test", evidence="test", confidence="High",
+ message="test",
+ evidence="test",
+ confidence="High",
)
@@ -49,6 +58,7 @@ def _fail() -> HardFail:
# 기본 동작
# ---------------------------------------------------------------------------
+
class TestRepairEngineNoop:
def test_empty_when_no_hard_fails(self):
engine = RepairEngine()
@@ -70,6 +80,7 @@ def test_empty_when_pois_list_is_empty(self):
# → deletion 단계 검증 가능
# ---------------------------------------------------------------------------
+
def _outlier_pois() -> list[POI]:
"""8개 POI — D(lat=38.5)가 A-C, E-H(lat=37.5) 사이의 지리적 이상치."""
return [
@@ -136,6 +147,7 @@ def test_deletion_explains_when_no_restaurant_nearby(self):
# Stay-time Tuning
# ---------------------------------------------------------------------------
+
class TestTimeTuneSuggestion:
def test_no_tune_when_within_limit(self):
"""친구(720min) 기준, 총 120min → 조정 불필요."""
@@ -169,6 +181,7 @@ def test_adjusted_durations_above_minimum(self):
# to_dict / is_empty
# ---------------------------------------------------------------------------
+
class TestResultModel:
def test_to_dict_is_serializable(self):
engine = RepairEngine()
@@ -189,3 +202,69 @@ def test_is_empty_false_when_has_deletion(self):
plan = _plan(["A", "B", "C", "D", "E", "F", "G", "H"])
result = engine.repair(plan, [_outlier_pois()], {}, hard_fails=[_fail()])
assert not result.is_empty
+
+
+# ---------------------------------------------------------------------------
+# total_estimated_gain — 서로 다른 날짜의 제안은 합산, 같은 날짜의 대안은 최댓값만
+# ---------------------------------------------------------------------------
+
+
+class TestTotalEstimatedGain:
+ def test_sums_across_different_days(self):
+ result = RepairResult(
+ deletions=[
+ DeletionSuggestion(
+ day_index=0,
+ candidate_name="A",
+ travel_saved_km=1.0,
+ reason="",
+ estimated_score_gain=10,
+ ),
+ DeletionSuggestion(
+ day_index=1,
+ candidate_name="B",
+ travel_saved_km=1.0,
+ reason="",
+ estimated_score_gain=5,
+ ),
+ ]
+ )
+ assert result.total_estimated_gain == 15
+
+ def test_takes_max_of_alternatives_on_same_day(self):
+ result = RepairResult(
+ deletions=[
+ DeletionSuggestion(
+ day_index=0,
+ candidate_name="A",
+ travel_saved_km=1.0,
+ reason="",
+ estimated_score_gain=10,
+ ),
+ DeletionSuggestion(
+ day_index=0,
+ candidate_name="B",
+ travel_saved_km=1.0,
+ reason="",
+ estimated_score_gain=15,
+ ),
+ ]
+ )
+ assert result.total_estimated_gain == 15
+
+ def test_zero_when_empty(self):
+ assert RepairResult().total_estimated_gain == 0
+
+ def test_included_in_to_dict(self):
+ result = RepairResult(
+ deletions=[
+ DeletionSuggestion(
+ day_index=0,
+ candidate_name="A",
+ travel_saved_km=1.0,
+ reason="",
+ estimated_score_gain=10,
+ ),
+ ]
+ )
+ assert result.to_dict()["total_estimated_gain"] == 10
diff --git a/tests/test_resolve_poi.py b/tests/test_resolve_poi.py
index 321b003..b48265f 100644
--- a/tests/test_resolve_poi.py
+++ b/tests/test_resolve_poi.py
@@ -1,4 +1,5 @@
"""_resolve_poi() 좌표 해석 폴백 순서 테스트 (카탈로그 → csv → kakao 키워드 → 지오코딩 → 서울 폴백)."""
+
from __future__ import annotations
from unittest.mock import patch
@@ -11,8 +12,16 @@
from src.api.main import app
_XLSX_HEADER = [
- "상호명", "도로명주소", "위도", "경도", "대분류코드", "대분류명", "영업시간",
- "TourAPI_contentid", "TourAPI_영업시간", "반려동물동반",
+ "상호명",
+ "도로명주소",
+ "위도",
+ "경도",
+ "대분류코드",
+ "대분류명",
+ "영업시간",
+ "TourAPI_contentid",
+ "TourAPI_영업시간",
+ "반려동물동반",
]
@@ -32,15 +41,28 @@ def jeju_xlsx_index(tmp_path, monkeypatch):
tmp_path / "제주특별자치도_통합_TourAPI병합.xlsx",
[
{ # TourAPI 매칭 성공 — 실측 영업시간·contentid 우선 사용, 반려동물 동반 가능
- "상호명": "제주아트센터", "도로명주소": "제주시 어딘가", "위도": "33.4", "경도": "126.5",
- "대분류코드": "VE", "대분류명": "문화관광",
- "영업시간": "10:00~19:00", "TourAPI_contentid": 1755806,
- "TourAPI_영업시간": "09:30~18:30 (휴게 12:00~13:00)", "반려동물동반": "Y",
+ "상호명": "제주아트센터",
+ "도로명주소": "제주시 어딘가",
+ "위도": "33.4",
+ "경도": "126.5",
+ "대분류코드": "VE",
+ "대분류명": "문화관광",
+ "영업시간": "10:00~19:00",
+ "TourAPI_contentid": 1755806,
+ "TourAPI_영업시간": "09:30~18:30 (휴게 12:00~13:00)",
+ "반려동물동반": "Y",
},
{ # TourAPI 미매칭 — 기존 영업시간 원문 텍스트로 폴백, 반려동물 동반 정보 없음
- "상호명": "클리프홀", "도로명주소": "서귀포시 어딘가", "위도": "33.38", "경도": "126.23",
- "대분류코드": "VE", "대분류명": "문화관광",
- "영업시간": "10:00~24:00", "TourAPI_contentid": "", "TourAPI_영업시간": "", "반려동물동반": "",
+ "상호명": "클리프홀",
+ "도로명주소": "서귀포시 어딘가",
+ "위도": "33.38",
+ "경도": "126.23",
+ "대분류코드": "VE",
+ "대분류명": "문화관광",
+ "영업시간": "10:00~24:00",
+ "TourAPI_contentid": "",
+ "TourAPI_영업시간": "",
+ "반려동물동반": "",
},
],
)
@@ -80,9 +102,15 @@ def test_resolve_poi_propagates_pet_friendly_flag(monkeypatch):
router._JEJU_CSV_INDEX,
router._normalize("반려동반테스트장소"),
{
- "name": "반려동반테스트장소", "lat": 33.4, "lng": 126.5,
- "region": "제주", "cat": "12", "cat_name": "관광지",
- "addr": "", "has_coords": True, "source": "jeju_csv",
+ "name": "반려동반테스트장소",
+ "lat": 33.4,
+ "lng": 126.5,
+ "region": "제주",
+ "cat": "12",
+ "cat_name": "관광지",
+ "addr": "",
+ "has_coords": True,
+ "source": "jeju_csv",
"pet_friendly": True,
},
)
diff --git a/tests/test_restaurant_catalog.py b/tests/test_restaurant_catalog.py
index 9c809d7..42819bd 100644
--- a/tests/test_restaurant_catalog.py
+++ b/tests/test_restaurant_catalog.py
@@ -1,15 +1,18 @@
"""RestaurantCatalog 유닛 테스트 (실제 CSV I/O 없음 — 인메모리 데이터 사용)."""
+
from __future__ import annotations
from src.data.restaurant_catalog import RestaurantCatalog
def _catalog() -> RestaurantCatalog:
- return RestaurantCatalog([
- {"name": "가까운식당", "lat": 33.500, "lng": 126.500}, # ~0km
- {"name": "먼식당", "lat": 33.700, "lng": 126.700}, # 반경 밖
- {"name": "자기자신", "lat": 33.500, "lng": 126.500},
- ])
+ return RestaurantCatalog(
+ [
+ {"name": "가까운식당", "lat": 33.500, "lng": 126.500}, # ~0km
+ {"name": "먼식당", "lat": 33.700, "lng": 126.700}, # 반경 밖
+ {"name": "자기자신", "lat": 33.500, "lng": 126.500},
+ ]
+ )
def test_nearby_returns_within_radius_sorted_by_distance():
diff --git a/tests/test_reward_engine.py b/tests/test_reward_engine.py
index a1ea679..3bc3c19 100644
--- a/tests/test_reward_engine.py
+++ b/tests/test_reward_engine.py
@@ -1,7 +1,6 @@
"""RewardEngine 유닛 테스트."""
-from __future__ import annotations
-import pytest
+from __future__ import annotations
from src.data.models import Scores
from src.scoring.reward_engine import generate_rewards
diff --git a/tests/test_route_matrix.py b/tests/test_route_matrix.py
new file mode 100644
index 0000000..d89df87
--- /dev/null
+++ b/tests/test_route_matrix.py
@@ -0,0 +1,54 @@
+"""운영 검증용 indexed route matrix 서비스 테스트."""
+
+import asyncio
+
+from src.data.models import POI
+from src.matrix.route_matrix import RouteMatrixService
+from src.validation.vrptw_engine import HaversineMatrix
+
+
+def _poi(name: str, lat: float, lng: float) -> POI:
+ return POI(
+ poi_id=name,
+ name=name,
+ lat=lat,
+ lng=lng,
+ open_start="09:00",
+ open_end="18:00",
+ duration_min=60,
+ category="12",
+ )
+
+
+class FakeRouteProvider:
+ def __init__(self):
+ self.prefetched = False
+
+ async def aprefetch_matrix(self, places):
+ self.prefetched = True
+
+ def get_travel_time(self, origin, destination):
+ return 120 if origin.name != destination.name else 0
+
+
+def test_build_uses_provider_seconds_as_minutes():
+ provider = FakeRouteProvider()
+ service = RouteMatrixService(provider=provider, mode="kakao")
+ pois = [_poi("A", 37.5, 127.0), _poi("B", 37.51, 127.01)]
+
+ matrix = asyncio.run(service.build(pois))
+
+ assert provider.prefetched is True
+ assert matrix[0][1]["travel_min"] == 2
+ assert matrix[1][0]["travel_min"] == 2
+ assert matrix[0][1]["mode"] == "kakao"
+
+
+def test_haversine_provider_is_used_when_api_key_is_unavailable():
+ service = RouteMatrixService(provider=HaversineMatrix())
+ pois = [_poi("A", 37.5, 127.0), _poi("B", 37.51, 127.01)]
+
+ matrix = asyncio.run(service.build(pois))
+
+ assert matrix[0][1]["travel_min"] > 0
+ assert matrix[0][1]["mode"] == "haversine_fallback"
diff --git a/tests/test_scoring.py b/tests/test_scoring.py
index c67c172..96f71ee 100644
--- a/tests/test_scoring.py
+++ b/tests/test_scoring.py
@@ -1,16 +1,17 @@
"""Tests for ScoreCalculator (TDD)."""
+
from __future__ import annotations
import pytest
-from src.data.models import DayPlan, HardFail, ItineraryPlan, PlaceInput, POI, Scores
+from src.data.models import POI, DayPlan, HardFail, ItineraryPlan, PlaceInput
from src.validation.scoring import WEIGHTS, ScoreCalculator
-
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
+
def make_poi(
poi_id: str = "1",
name: str = "POI",
@@ -20,9 +21,14 @@ def make_poi(
duration_min: int = 60,
) -> POI:
return POI(
- poi_id=poi_id, name=name, lat=lat, lng=lng,
- open_start="09:00", open_end="18:00",
- duration_min=duration_min, category=category,
+ poi_id=poi_id,
+ name=name,
+ lat=lat,
+ lng=lng,
+ open_start="09:00",
+ open_end="18:00",
+ duration_min=duration_min,
+ category=category,
)
@@ -62,6 +68,7 @@ def make_hard_fail() -> HardFail:
# Fixtures
# ---------------------------------------------------------------------------
+
@pytest.fixture
def calc() -> ScoreCalculator:
return ScoreCalculator()
@@ -92,6 +99,7 @@ def sample_plan(sample_pois) -> ItineraryPlan:
# WEIGHTS constant
# ---------------------------------------------------------------------------
+
class TestWeights:
def test_weights_sum_to_one(self):
total = sum(WEIGHTS.values())
@@ -99,7 +107,11 @@ def test_weights_sum_to_one(self):
def test_weights_keys(self):
assert set(WEIGHTS.keys()) == {
- "efficiency", "feasibility", "purpose_fit", "flow", "area_intensity"
+ "efficiency",
+ "feasibility",
+ "purpose_fit",
+ "flow",
+ "area_intensity",
}
@@ -107,15 +119,14 @@ def test_weights_keys(self):
# compute() — final_score range
# ---------------------------------------------------------------------------
+
class TestCompute:
def test_final_score_in_range(self, calc, sample_pois, sample_matrix, sample_plan):
scores, final_score = calc.compute(sample_plan, sample_pois, sample_matrix, [])
assert 0 <= final_score <= 100
def test_hard_fail_caps_score_at_59(self, calc, sample_pois, sample_matrix, sample_plan):
- _, final_score = calc.compute(
- sample_plan, sample_pois, sample_matrix, [make_hard_fail()]
- )
+ _, final_score = calc.compute(sample_plan, sample_pois, sample_matrix, [make_hard_fail()])
assert final_score <= 59
def test_no_hard_fail_can_exceed_59(self, calc, sample_pois, sample_matrix, sample_plan):
@@ -137,12 +148,12 @@ def test_scores_object_fields(self, calc, sample_pois, sample_matrix, sample_pla
# _calc_efficiency
# ---------------------------------------------------------------------------
+
class TestEfficiency:
def test_optimal_order_is_one(self, calc):
# 4 POIs in a straight line — user visits in order → efficiency ≈ 1.0
pois = [
- make_poi(poi_id=str(i), name=f"P{i}", lat=37.5, lng=127.0 + i * 0.01)
- for i in range(4)
+ make_poi(poi_id=str(i), name=f"P{i}", lat=37.5, lng=127.0 + i * 0.01) for i in range(4)
]
efficiency = calc._calc_efficiency(pois, {})
assert efficiency == pytest.approx(1.0, abs=0.05)
@@ -167,6 +178,7 @@ def test_single_poi_returns_one(self, calc):
# _calc_feasibility
# ---------------------------------------------------------------------------
+
class TestFeasibility:
def test_no_hard_fails_hard_is_one(self, calc, sample_pois, sample_matrix, sample_plan):
feasibility = calc._calc_feasibility(sample_plan, sample_pois, sample_matrix, [])
@@ -174,7 +186,9 @@ def test_no_hard_fails_hard_is_one(self, calc, sample_pois, sample_matrix, sampl
assert feasibility >= 0.5
def test_hard_fail_reduces_feasibility(self, calc, sample_pois, sample_matrix, sample_plan):
- with_fail = calc._calc_feasibility(sample_plan, sample_pois, sample_matrix, [make_hard_fail()])
+ with_fail = calc._calc_feasibility(
+ sample_plan, sample_pois, sample_matrix, [make_hard_fail()]
+ )
no_fail = calc._calc_feasibility(sample_plan, sample_pois, sample_matrix, [])
assert with_fail < no_fail
@@ -187,6 +201,7 @@ def test_feasibility_in_range(self, calc, sample_pois, sample_matrix, sample_pla
# _calc_purpose_fit
# ---------------------------------------------------------------------------
+
class TestPurposeFit:
def test_cultural_all_cultural_high(self, calc):
pois = [make_poi(poi_id=str(i), name=f"P{i}", category="14") for i in range(4)]
@@ -210,6 +225,7 @@ def test_no_travel_type_returns_half(self, calc):
# _cosine_distance
# ---------------------------------------------------------------------------
+
class TestCosineDistance:
def test_identical_vectors(self, calc):
v = {"a": 0.5, "b": 0.5}
diff --git a/tests/test_security.py b/tests/test_security.py
new file mode 100644
index 0000000..3a28a59
--- /dev/null
+++ b/tests/test_security.py
@@ -0,0 +1,19 @@
+"""API 인증·레이트리밋 경계 테스트."""
+
+from fastapi.testclient import TestClient
+
+from src.api.main import app
+
+
+def test_production_requires_bearer_token(monkeypatch):
+ monkeypatch.setenv("ENVIRONMENT", "production")
+ monkeypatch.setenv("API_AUTH_TOKEN", "test-secret")
+ client = TestClient(app)
+
+ assert client.post("/api/validate", json={}).status_code == 401
+ assert (
+ client.post(
+ "/api/validate", json={}, headers={"Authorization": "Bearer test-secret"}
+ ).status_code
+ == 422
+ )
diff --git a/tests/test_settings.py b/tests/test_settings.py
new file mode 100644
index 0000000..02a9d64
--- /dev/null
+++ b/tests/test_settings.py
@@ -0,0 +1,11 @@
+"""설정 파일 경로와 환경변수 경계 테스트."""
+
+from pathlib import Path
+
+from src.data.models import Settings
+
+
+def test_settings_env_file_is_project_absolute_path():
+ env_file = Settings.model_config["env_file"]
+
+ assert Path(env_file).is_absolute()
diff --git a/tests/test_theme_alignment.py b/tests/test_theme_alignment.py
index 6766bf1..9421d4d 100644
--- a/tests/test_theme_alignment.py
+++ b/tests/test_theme_alignment.py
@@ -1,4 +1,5 @@
"""Tests for src/scoring/theme_alignment.py — LLM mocking 필수."""
+
from __future__ import annotations
from unittest.mock import MagicMock
@@ -7,12 +8,10 @@
from src.data.theme_taxonomy import UserPreferences
from src.scoring.theme_alignment import (
+ _CACHE,
PENALTY_CRIT,
- PENALTY_RISK,
POIWithCategory,
ThemeAlignmentJudge,
- ThemeJudgment,
- _CACHE,
_classify_score,
_parse_llm_response,
)
@@ -74,14 +73,19 @@ def test_high_alignment_no_penalty(self):
"""LLM이 0.9 응답 → 패널티 0."""
mock_client = MagicMock()
mock_msg = MagicMock()
- mock_msg.content = [MagicMock(text='{"score": 0.9, "reasoning": "잘 맞음", "mismatched_places": []}')]
+ mock_msg.content = [
+ MagicMock(text='{"score": 0.9, "reasoning": "잘 맞음", "mismatched_places": []}')
+ ]
mock_client.messages.create.return_value = mock_msg
judge = ThemeAlignmentJudge(api_key="dummy", client=mock_client)
prefs = UserPreferences(place_types=["산"], travel_styles=["자연과 함께"])
- report = judge.evaluate(prefs, [
- POIWithCategory(name="한라산", category_name="자연관광지/산", visit_order=1),
- ])
+ report = judge.evaluate(
+ prefs,
+ [
+ POIWithCategory(name="한라산", category_name="자연관광지/산", visit_order=1),
+ ],
+ )
assert report.judgment is not None
assert report.judgment.score == 0.9
@@ -91,14 +95,19 @@ def test_low_alignment_critical(self):
"""LLM이 0.3 응답 → CRITICAL 패널티."""
mock_client = MagicMock()
mock_msg = MagicMock()
- mock_msg.content = [MagicMock(text='{"score": 0.3, "reasoning": "안 맞음", "mismatched_places": ["카페A"]}')]
+ mock_msg.content = [
+ MagicMock(text='{"score": 0.3, "reasoning": "안 맞음", "mismatched_places": ["카페A"]}')
+ ]
mock_client.messages.create.return_value = mock_msg
judge = ThemeAlignmentJudge(api_key="dummy", client=mock_client)
prefs = UserPreferences(place_types=["액티비티"], travel_styles=[])
- report = judge.evaluate(prefs, [
- POIWithCategory(name="카페A", category_name="음식점/카페", visit_order=1),
- ])
+ report = judge.evaluate(
+ prefs,
+ [
+ POIWithCategory(name="카페A", category_name="음식점/카페", visit_order=1),
+ ],
+ )
assert report.penalty == PENALTY_CRIT
assert any(d.rule == "theme_alignment" for d in report.deep_dive)
@@ -107,7 +116,9 @@ def test_cache_hit_skips_second_call(self):
"""동일 입력으로 두 번 호출 시 LLM은 1회만 호출."""
mock_client = MagicMock()
mock_msg = MagicMock()
- mock_msg.content = [MagicMock(text='{"score": 0.7, "reasoning": "x", "mismatched_places": []}')]
+ mock_msg.content = [
+ MagicMock(text='{"score": 0.7, "reasoning": "x", "mismatched_places": []}')
+ ]
mock_client.messages.create.return_value = mock_msg
judge = ThemeAlignmentJudge(api_key="dummy", client=mock_client)
diff --git a/tests/test_theme_taxonomy.py b/tests/test_theme_taxonomy.py
index 689fb6c..34dfb91 100644
--- a/tests/test_theme_taxonomy.py
+++ b/tests/test_theme_taxonomy.py
@@ -1,4 +1,5 @@
"""Tests for src/data/theme_taxonomy.py — 2축 테마 + 매핑."""
+
from __future__ import annotations
import pytest
diff --git a/tests/test_travel_ratio.py b/tests/test_travel_ratio.py
index abe7e32..60f3813 100644
--- a/tests/test_travel_ratio.py
+++ b/tests/test_travel_ratio.py
@@ -1,12 +1,9 @@
"""Tests for src/scoring/travel_ratio.py."""
-from __future__ import annotations
-import pytest
+from __future__ import annotations
from src.data.models import VRPTWDay, VRPTWPlace
from src.scoring.travel_ratio import (
- PENALTY_RISK,
- PENALTY_WARN,
evaluate_travel_ratio,
)
from src.validation.vrptw_engine import HaversineMatrix
@@ -14,19 +11,26 @@
def _make_place(name: str, lng: float, lat: float, stay_min: int = 60):
return VRPTWPlace(
- name=name, lng=lng, lat=lat,
- open="09:00", close="22:00", stay_duration=stay_min, is_depot=False,
+ name=name,
+ lng=lng,
+ lat=lat,
+ open="09:00",
+ close="22:00",
+ stay_duration=stay_min,
+ is_depot=False,
)
def test_no_penalty_when_ratio_low():
"""4개 장소가 모두 가까이 있으면 travel_ratio가 낮음 → 패널티 0."""
- day = VRPTWDay(places=[
- _make_place("A", 127.0, 37.5),
- _make_place("B", 127.001, 37.501),
- _make_place("C", 127.002, 37.502),
- _make_place("D", 127.003, 37.503),
- ])
+ day = VRPTWDay(
+ places=[
+ _make_place("A", 127.0, 37.5),
+ _make_place("B", 127.001, 37.501),
+ _make_place("C", 127.002, 37.502),
+ _make_place("D", 127.003, 37.503),
+ ]
+ )
report = evaluate_travel_ratio([day], matrix=HaversineMatrix())
assert report.total_penalty == 0
assert report.per_day[0].travel_ratio < 0.20
@@ -34,10 +38,12 @@ def test_no_penalty_when_ratio_low():
def test_penalty_when_ratio_high():
"""장소가 멀리 떨어져 이동 시간이 관광 시간을 압도하면 패널티 발생."""
- day = VRPTWDay(places=[
- _make_place("서울", 126.978, 37.566, stay_min=15),
- _make_place("부산", 129.075, 35.180, stay_min=15),
- ])
+ day = VRPTWDay(
+ places=[
+ _make_place("서울", 126.978, 37.566, stay_min=15),
+ _make_place("부산", 129.075, 35.180, stay_min=15),
+ ]
+ )
report = evaluate_travel_ratio([day], matrix=HaversineMatrix())
# 서울→부산 직선거리 약 325km, 30km/h 가정 시 이동 ~10시간
# vs 체류 30분 → ratio ≈ 0.95 → CRITICAL
@@ -47,14 +53,18 @@ def test_penalty_when_ratio_high():
def test_overall_ratio_aggregates_across_days():
days = [
- VRPTWDay(places=[
- _make_place("A", 127.0, 37.5, stay_min=60),
- _make_place("B", 127.001, 37.501, stay_min=60),
- ]),
- VRPTWDay(places=[
- _make_place("C", 127.0, 37.5, stay_min=60),
- _make_place("D", 127.001, 37.501, stay_min=60),
- ]),
+ VRPTWDay(
+ places=[
+ _make_place("A", 127.0, 37.5, stay_min=60),
+ _make_place("B", 127.001, 37.501, stay_min=60),
+ ]
+ ),
+ VRPTWDay(
+ places=[
+ _make_place("C", 127.0, 37.5, stay_min=60),
+ _make_place("D", 127.001, 37.501, stay_min=60),
+ ]
+ ),
]
report = evaluate_travel_ratio(days, matrix=HaversineMatrix())
assert len(report.per_day) == 2
diff --git a/tests/test_vrptw_engine.py b/tests/test_vrptw_engine.py
index 7d11365..8bb3fdb 100644
--- a/tests/test_vrptw_engine.py
+++ b/tests/test_vrptw_engine.py
@@ -1,11 +1,11 @@
"""Tests for VRPTW validation engine (TDD)."""
+
from __future__ import annotations
-import math
-from typing import Any
from unittest.mock import patch
import pytest
+from pydantic import ValidationError
from src.data.models import VRPTWDay, VRPTWPlace, VRPTWRequest, VRPTWResult
from src.validation.vrptw_engine import (
@@ -21,6 +21,7 @@
# Fixtures
# ---------------------------------------------------------------------------
+
def make_place(
name: str = "POI",
lng: float = 127.0,
@@ -51,6 +52,7 @@ def make_place(
# HaversineMatrix
# ---------------------------------------------------------------------------
+
class TestHaversineMatrix:
def test_same_point_is_zero(self):
m = HaversineMatrix()
@@ -72,6 +74,7 @@ def test_symmetry(self):
# CachedRouteMatrix
# ---------------------------------------------------------------------------
+
class TestCachedRouteMatrix:
def test_cache_hit(self):
data = {"127.1,37.5|127.2,37.5": 600}
@@ -102,6 +105,7 @@ def test_load_from_dict(self):
# Depot constraint enforcement
# ---------------------------------------------------------------------------
+
class TestDepotConstraint:
def _engine_with_haversine(self) -> VRPTWEngine:
return VRPTWEngine(matrix=HaversineMatrix())
@@ -110,7 +114,7 @@ def test_2n3d_day1_must_end_at_depot(self):
"""2박3일: day1 last place must be depot."""
req = VRPTWRequest(
days=[
- VRPTWDay(places=[DEPOT, POI_A, POI_B]), # depot only at start
+ VRPTWDay(places=[DEPOT, POI_A, POI_B]), # depot only at start
VRPTWDay(places=[DEPOT, POI_C, DEPOT]),
VRPTWDay(places=[DEPOT, POI_A]),
]
@@ -118,8 +122,7 @@ def test_2n3d_day1_must_end_at_depot(self):
engine = self._engine_with_haversine()
result = engine.validate(req)
has_depot_warning = any(
- "depot" in d.fact.lower() or "숙소" in d.fact
- for d in result.deep_dive
+ "depot" in d.fact.lower() or "숙소" in d.fact for d in result.deep_dive
)
assert has_depot_warning or result.risk_score < 100
@@ -133,7 +136,9 @@ def test_2n3d_middle_day_must_start_and_end_at_depot(self):
)
engine = self._engine_with_haversine()
result = engine.validate(req)
- depot_issues = [d for d in result.deep_dive if "depot" in d.fact.lower() or "숙소" in d.fact]
+ depot_issues = [
+ d for d in result.deep_dive if "depot" in d.fact.lower() or "숙소" in d.fact
+ ]
assert len(depot_issues) >= 1
def test_1n2d_no_depot_constraint_applied(self):
@@ -147,9 +152,9 @@ def test_1n2d_no_depot_constraint_applied(self):
engine = self._engine_with_haversine()
result = engine.validate(req)
depot_issues = [
- d for d in result.deep_dive
- if ("depot" in d.rule.lower() or "depot" in d.fact.lower())
- and "1박" not in d.fact
+ d
+ for d in result.deep_dive
+ if ("depot" in d.rule.lower() or "depot" in d.fact.lower()) and "1박" not in d.fact
]
assert len(depot_issues) == 0
@@ -158,25 +163,24 @@ def test_1n2d_no_depot_constraint_applied(self):
# Time window feasibility
# ---------------------------------------------------------------------------
+
class TestTimeWindowFeasibility:
def _engine(self) -> VRPTWEngine:
return VRPTWEngine(matrix=HaversineMatrix())
def test_feasible_schedule_passes(self):
- req = VRPTWRequest(
- days=[VRPTWDay(places=[POI_A, POI_B])]
- )
+ req = VRPTWRequest(days=[VRPTWDay(places=[POI_A, POI_B])])
engine = self._engine()
result = engine.validate(req)
- hard_fails = [d for d in result.deep_dive if d.risk == "CRITICAL" and "time_window" in d.rule.lower()]
+ hard_fails = [
+ d for d in result.deep_dive if d.risk == "CRITICAL" and "time_window" in d.rule.lower()
+ ]
assert len(hard_fails) == 0
def test_infeasible_close_time_triggers_critical(self):
"""A place that closes at 09:05 — impossible to visit after travel from A."""
tight = make_place("TightPOI", 127.2, 37.5, "08:00", "09:05", 60)
- req = VRPTWRequest(
- days=[VRPTWDay(places=[POI_A, tight])]
- )
+ req = VRPTWRequest(days=[VRPTWDay(places=[POI_A, tight])])
engine = self._engine()
result = engine.validate(req)
critical = [d for d in result.deep_dive if d.risk == "CRITICAL"]
@@ -187,19 +191,29 @@ def test_safety_margin_warning(self):
# POI_A at 127.1, stay 60 min → depart 10:00; near_close ~0.1° away → arrive ~10:20
# close = 11:00 → margin = 40 min < 60 min → safety_margin warning
near_close = make_place("NearClose", 127.2, 37.5, "08:00", "11:00", 30)
- req = VRPTWRequest(
- days=[VRPTWDay(places=[POI_A, near_close])]
- )
+ req = VRPTWRequest(days=[VRPTWDay(places=[POI_A, near_close])])
engine = self._engine()
result = engine.validate(req)
safety_issues = [d for d in result.deep_dive if "safety_margin" in d.rule.lower()]
assert len(safety_issues) >= 1
+ def test_request_start_time_is_used(self):
+ late_poi = make_place("Late", 127.0, 37.5, "09:00", "10:00", 30)
+ req = VRPTWRequest(
+ days=[VRPTWDay(places=[late_poi])],
+ start_time="10:30",
+ )
+
+ result = self._engine().validate(req)
+
+ assert any(d.risk == "CRITICAL" for d in result.deep_dive)
+
# ---------------------------------------------------------------------------
# Efficiency gap
# ---------------------------------------------------------------------------
+
class TestEfficiencyGap:
def test_optimal_order_same_as_user_gives_zero_gap(self):
"""With 2 POIs the optimal is always the same, gap should be 0 or minimal."""
@@ -222,6 +236,7 @@ def test_reversed_inefficient_route_shows_gap(self):
# Fatigue score
# ---------------------------------------------------------------------------
+
class TestFatigueScore:
def test_12h_schedule_no_fatigue_penalty(self):
# 09:00 start, 21:00 end = exactly 12h
@@ -253,13 +268,20 @@ def test_long_schedule_triggers_fatigue(self):
# OR-Tools graceful degradation
# ---------------------------------------------------------------------------
+
class TestORToolsDegradation:
def test_missing_ortools_still_returns_result(self):
"""When ortools is not available, engine still returns a VRPTWResult."""
req = VRPTWRequest(days=[VRPTWDay(places=[POI_A, POI_B])])
- with patch.dict("sys.modules", {"ortools": None, "ortools.constraint_solver": None,
- "ortools.constraint_solver.routing_enums_pb2": None,
- "ortools.constraint_solver.pywrapcsp": None}):
+ with patch.dict(
+ "sys.modules",
+ {
+ "ortools": None,
+ "ortools.constraint_solver": None,
+ "ortools.constraint_solver.routing_enums_pb2": None,
+ "ortools.constraint_solver.pywrapcsp": None,
+ },
+ ):
# Re-import engine in patched context is complex; instead directly test the
# fallback path by calling with ortools_available=False
engine = VRPTWEngine(matrix=HaversineMatrix(), ortools_available=False)
@@ -274,6 +296,7 @@ def test_missing_ortools_still_returns_result(self):
# Risk score bounds
# ---------------------------------------------------------------------------
+
class TestRiskScore:
def test_risk_score_in_0_100(self):
req = VRPTWRequest(days=[VRPTWDay(places=[POI_A, POI_B])])
@@ -295,6 +318,7 @@ def test_pass_fail_threshold(self):
# Constants are tunable
# ---------------------------------------------------------------------------
+
def test_constants_accessible():
assert EFFICIENCY_GAP_THRESHOLD == 0.20
assert FATIGUE_HOURS_LIMIT == 12
@@ -305,38 +329,46 @@ def test_constants_accessible():
# Pydantic model validation
# ---------------------------------------------------------------------------
+
class TestModelValidation:
def test_invalid_lat_raises(self):
- with pytest.raises(Exception):
+ with pytest.raises(ValidationError):
VRPTWPlace(name="X", lng=127.0, lat=91.0, open="09:00", close="18:00", stay_duration=60)
def test_invalid_lng_raises(self):
- with pytest.raises(Exception):
+ with pytest.raises(ValidationError):
VRPTWPlace(name="X", lng=181.0, lat=37.0, open="09:00", close="18:00", stay_duration=60)
def test_invalid_time_format_raises(self):
- with pytest.raises(Exception):
+ with pytest.raises(ValidationError):
VRPTWPlace(name="X", lng=127.0, lat=37.0, open="9:00", close="18:00", stay_duration=60)
def test_invalid_time_value_raises(self):
- with pytest.raises(Exception):
+ with pytest.raises(ValidationError):
VRPTWPlace(name="X", lng=127.0, lat=37.0, open="25:00", close="18:00", stay_duration=60)
def test_negative_stay_raises(self):
- with pytest.raises(Exception):
+ with pytest.raises(ValidationError):
VRPTWPlace(name="X", lng=127.0, lat=37.0, open="09:00", close="18:00", stay_duration=-1)
def test_zero_stay_allowed_for_depot(self):
- p = VRPTWPlace(name="Hotel", lng=127.0, lat=37.0, open="00:00", close="23:59",
- stay_duration=0, is_depot=True)
+ p = VRPTWPlace(
+ name="Hotel",
+ lng=127.0,
+ lat=37.0,
+ open="00:00",
+ close="23:59",
+ stay_duration=0,
+ is_depot=True,
+ )
assert p.stay_duration == 0
def test_empty_day_raises(self):
- with pytest.raises(Exception):
+ with pytest.raises(ValidationError):
VRPTWDay(places=[])
def test_empty_days_raises(self):
- with pytest.raises(Exception):
+ with pytest.raises(ValidationError):
VRPTWRequest(days=[])
def test_open_minutes_property(self):
@@ -352,6 +384,7 @@ def test_close_minutes_property(self):
# Efficiency gap over threshold triggers deep_dive entry
# ---------------------------------------------------------------------------
+
class TestEfficiencyGapThreshold:
def test_gap_over_threshold_adds_warning(self):
"""If efficiency gap > 20%, a deep_dive WARNING should appear."""
@@ -373,6 +406,7 @@ def test_gap_over_threshold_adds_warning(self):
# Multi-day result structure
# ---------------------------------------------------------------------------
+
class TestMultiDayResult:
def test_multi_day_returns_per_day_comparison(self):
req = VRPTWRequest(
@@ -412,18 +446,20 @@ def test_single_place_day_no_travel(self):
# Summary string
# ---------------------------------------------------------------------------
+
def test_summary_contains_score():
req = VRPTWRequest(days=[VRPTWDay(places=[POI_A, POI_B])])
engine = VRPTWEngine(matrix=HaversineMatrix())
result = engine.validate(req)
assert str(result.risk_score) in result.summary
- assert ("PASS" in result.summary or "FAIL" in result.summary)
+ assert "PASS" in result.summary or "FAIL" in result.summary
# ---------------------------------------------------------------------------
# DeepDiveItem structure
# ---------------------------------------------------------------------------
+
def test_deep_dive_items_have_all_fields():
"""Every DeepDiveItem must have non-empty fact, rule, risk, suggestion."""
tight = make_place("Tight", 127.2, 37.5, "08:00", "09:05", 60)
@@ -441,9 +477,11 @@ def test_deep_dive_items_have_all_fields():
# CachedRouteMatrix.from_file (uses actual cache_route.json)
# ---------------------------------------------------------------------------
+
def test_cached_matrix_from_actual_file():
"""Smoke test: load real cache_route.json and verify at least one hit."""
import os
+
cache_path = os.path.join(
os.path.dirname(__file__), "..", "phases", "0-setup", "cache_route.json"
)
diff --git a/tests/test_warning.py b/tests/test_warning.py
index a8a7a4b..6eeb82c 100644
--- a/tests/test_warning.py
+++ b/tests/test_warning.py
@@ -1,16 +1,17 @@
"""Tests for WarningDetector (TDD)."""
+
from __future__ import annotations
import pytest
-from src.data.models import DayPlan, ItineraryPlan, PlaceInput, POI
+from src.data.models import POI, DayPlan, ItineraryPlan, PlaceInput
from src.validation.warning import WarningDetector
-
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
+
def make_poi(
poi_id: str = "1",
name: str = "POI",
@@ -20,9 +21,14 @@ def make_poi(
duration_min: int = 60,
) -> POI:
return POI(
- poi_id=poi_id, name=name, lat=lat, lng=lng,
- open_start="09:00", open_end="18:00",
- duration_min=duration_min, category=category,
+ poi_id=poi_id,
+ name=name,
+ lat=lat,
+ lng=lng,
+ open_start="09:00",
+ open_end="18:00",
+ duration_min=duration_min,
+ category=category,
)
@@ -55,6 +61,7 @@ def make_matrix(pairs: dict[tuple[int, int], float]) -> dict:
# Fixtures
# ---------------------------------------------------------------------------
+
@pytest.fixture
def detector() -> WarningDetector:
return WarningDetector()
@@ -64,6 +71,7 @@ def detector() -> WarningDetector:
# DENSE_SCHEDULE
# ---------------------------------------------------------------------------
+
class TestDenseSchedule:
def test_dense_trigger_baby(self, detector):
# 아기동반 피로도 한계 8h=480분, 4×60 + 3×100 = 540 > 480 → 발동
@@ -106,6 +114,7 @@ def test_dense_message_includes_party_type(self, detector):
# PHYSICAL_STRAIN
# ---------------------------------------------------------------------------
+
class TestPhysicalStrain:
def test_strain_trigger(self, detector):
# POIs ~13 km apart × 3 legs ≈ 39 km total > 30 km threshold
@@ -121,10 +130,7 @@ def test_strain_trigger(self, detector):
assert "PHYSICAL_STRAIN" in types
def test_no_strain_short_distance(self, detector):
- pois = [
- make_poi(poi_id=str(i), name=f"P{i}", lat=37.5, lng=127.0)
- for i in range(4)
- ]
+ pois = [make_poi(poi_id=str(i), name=f"P{i}", lat=37.5, lng=127.0) for i in range(4)]
plan = make_plan([f"P{i}" for i in range(4)])
warns = detector.detect(plan, pois, {})
types = [w.warning_type for w in warns]
@@ -135,13 +141,11 @@ def test_no_strain_short_distance(self, detector):
# PURPOSE_MISMATCH
# ---------------------------------------------------------------------------
+
class TestPurposeMismatch:
def test_mismatch_cultural_all_sports(self, detector):
# travel_type=cultural, all POIs are 레포츠(15) → mismatch
- pois = [
- make_poi(poi_id=str(i), name=f"P{i}", category="15")
- for i in range(4)
- ]
+ pois = [make_poi(poi_id=str(i), name=f"P{i}", category="15") for i in range(4)]
plan = make_plan([f"P{i}" for i in range(4)], travel_type="cultural")
warns = detector.detect(plan, pois, {})
types = [w.warning_type for w in warns]
@@ -149,10 +153,7 @@ def test_mismatch_cultural_all_sports(self, detector):
def test_no_mismatch_cultural_all_cultural(self, detector):
# travel_type=cultural, all POIs are 문화시설(14) → no mismatch
- pois = [
- make_poi(poi_id=str(i), name=f"P{i}", category="14")
- for i in range(4)
- ]
+ pois = [make_poi(poi_id=str(i), name=f"P{i}", category="14") for i in range(4)]
plan = make_plan([f"P{i}" for i in range(4)], travel_type="cultural")
warns = detector.detect(plan, pois, {})
types = [w.warning_type for w in warns]
@@ -170,6 +171,7 @@ def test_no_mismatch_when_no_travel_type(self, detector):
# AREA_REVISIT
# ---------------------------------------------------------------------------
+
class TestAreaRevisit:
def test_consecutive_same_category_triggers(self, detector):
# 3 consecutive "14" → AREA_REVISIT
@@ -227,12 +229,10 @@ def test_two_consecutive_no_trigger(self, detector):
# Warning model fields
# ---------------------------------------------------------------------------
+
class TestWarningFields:
def test_warning_has_confidence_from_types(self, detector):
- pois = [
- make_poi(poi_id=str(i), name=f"P{i}", category="15")
- for i in range(4)
- ]
+ pois = [make_poi(poi_id=str(i), name=f"P{i}", category="15") for i in range(4)]
plan = make_plan([f"P{i}" for i in range(4)], travel_type="cultural")
warns = detector.detect(plan, pois, {})
mismatch = next((w for w in warns if w.warning_type == "PURPOSE_MISMATCH"), None)
@@ -252,6 +252,7 @@ def test_warning_message_not_empty(self, detector):
# day_index / poi_names threading
# ---------------------------------------------------------------------------
+
class TestDayIndex:
def test_day_index_defaults_to_none(self, detector):
pois = [make_poi(poi_id=str(i), name=f"P{i}", duration_min=60) for i in range(4)]