hyungi
dcf99b377e
- fulltext_worker.reconcile_unresolved: EXISTS 서브쿼리 aliased(ProcessingQueue) — auto-correlation 이 FROM 전부 제거해 매 실행 InvalidRequestError (안전망 dead code). SQLAlchemy 2.0.50 컴파일 재현·수정 확인. - news_collector._fetch_rss: ETag/Last-Modified/content-hash 영속을 bozo 파싱 검증 뒤로 이동 — 부패 응답 워터마크 저장 시 영구 304-skip 차단. - news_collector.run: 모듈 락으로 수동 collect vs 6h 스케줄 동시 실행 차단 — _get_or_create_health 동시 INSERT 의 uq_source_health_source_id 위반이 사이클 전체를 죽이는 경합 봉쇄. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
555 lines
23 KiB
Python
555 lines
23 KiB
Python
"""뉴스 수집 워커 — RSS/API에서 기사 수집, documents에 저장
|
||
|
||
plan crawl-24x7-1 A그룹 (2026-06-10):
|
||
A-1 조건부 GET(ETag/Last-Modified 그대로 재전송) + 콘텐츠 해시 변경감지
|
||
A-2 fulltext_policy='page' 소스는 'fulltext' stage 로 본문 승격 위임
|
||
A-5 source_health 기록 + circuit breaker (소스별 실패 격리)
|
||
A-6 first-wins + 포털 전재 2차 dedup (제목+최근 3일, 12자 이상 제목 한정)
|
||
"""
|
||
|
||
import asyncio
|
||
import hashlib
|
||
import re
|
||
from datetime import datetime, timedelta, timezone
|
||
from html import unescape
|
||
from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
|
||
|
||
import feedparser
|
||
import httpx
|
||
from sqlalchemy import select
|
||
|
||
from core.crawl_politeness import CRAWL_UA
|
||
from core.database import async_session
|
||
from core.utils import setup_logger
|
||
from models.document import Document
|
||
from models.news_source import NewsSource
|
||
from models.queue import enqueue_stage
|
||
from models.source_health import SourceHealth
|
||
|
||
logger = setup_logger("news_collector")
|
||
|
||
# 카테고리 표준화 매핑
|
||
CATEGORY_MAP = {
|
||
# 한국어
|
||
"국제": "International", "정치": "Politics", "경제": "Economy",
|
||
"사회": "Society", "문화": "Culture", "산업": "Industry",
|
||
"환경": "Environment", "기술": "Technology",
|
||
# 영어
|
||
"World": "International", "International": "International",
|
||
"Technology": "Technology", "Tech": "Technology", "Sci-Tech": "Technology",
|
||
"Arts": "Culture", "Culture": "Culture",
|
||
"Climate": "Environment", "Environment": "Environment",
|
||
# 일본어
|
||
"国際": "International", "文化": "Culture", "科学": "Technology",
|
||
# 독일어
|
||
"Kultur": "Culture", "Wissenschaft": "Technology",
|
||
# 프랑스어
|
||
"Environnement": "Environment",
|
||
}
|
||
|
||
|
||
class FeedError(Exception):
|
||
"""소스 단위 fetch/parse 실패 — run() 이 source_health 실패로 기록."""
|
||
|
||
|
||
def _normalize_category(raw: str) -> str:
|
||
"""카테고리 표준화"""
|
||
return CATEGORY_MAP.get(raw, CATEGORY_MAP.get(raw.strip(), "Other"))
|
||
|
||
|
||
def _clean_html(text: str, max_len: int | None = 1000) -> str:
|
||
"""HTML 태그 제거 + 정제. max_len=None 이면 절단 없음 (feed-full 전문용)."""
|
||
if not text:
|
||
return ""
|
||
text = re.sub(r"<[^>]+>", "", text)
|
||
text = unescape(text)
|
||
text = text.strip()
|
||
return text if max_len is None else text[:max_len]
|
||
|
||
|
||
# tracking 파라미터 판별 — prefix(utm_/at_=BBC/ns_=BBC/mc_=mailchimp) + 단독 키
|
||
_TRACKING_PREFIXES = ("utm_", "at_", "ns_", "mc_")
|
||
_TRACKING_PARAMS = {"fbclid", "gclid", "igshid", "ref", "smid", "partner", "cmp", "ocid", "ftag"}
|
||
|
||
|
||
def _normalize_url(url: str) -> str:
|
||
"""URL 정규화 — tracking 파라미터만 제거, 콘텐츠 식별 파라미터는 보존.
|
||
|
||
query 전체 제거 금지: hada.io/topic?id= · aitimes articleView.html?idxno= ·
|
||
HN item?id= 등 query-식별 사이트에서 별개 기사가 같은 URL 로 붕괴된다.
|
||
저장(edit_url)·조회 양쪽이 이 함수를 공유해야 dedup 이 성립.
|
||
"""
|
||
parsed = urlparse(url)
|
||
kept = [
|
||
(k, v) for k, v in parse_qsl(parsed.query, keep_blank_values=True)
|
||
if not (k.lower().startswith(_TRACKING_PREFIXES) or k.lower() in _TRACKING_PARAMS)
|
||
]
|
||
return urlunparse((parsed.scheme, parsed.netloc, parsed.path, "", urlencode(kept), ""))
|
||
|
||
|
||
def _article_hash(title: str, published: str, source_name: str) -> str:
|
||
"""기사 고유 해시 (중복 체크용)"""
|
||
key = f"{title}|{published}|{source_name}"
|
||
return hashlib.sha256(key.encode()).hexdigest()[:32]
|
||
|
||
|
||
def _normalize_to_utc(dt) -> datetime:
|
||
"""다양한 시간 형식을 UTC로 정규화"""
|
||
if isinstance(dt, datetime):
|
||
if dt.tzinfo is None:
|
||
return dt.replace(tzinfo=timezone.utc)
|
||
return dt.astimezone(timezone.utc)
|
||
return datetime.now(timezone.utc)
|
||
|
||
|
||
# ── A-5: circuit breaker 정책 ──
|
||
# 연속 실패 >= OPEN 임계 → open (재시도 간격 지수 확대, 6h × 2^n, cap 48h)
|
||
# 연속 실패 > DISABLE 임계 → disabled (수집 제외 + 가시 로그, 수동 복구 대상)
|
||
# news_sources.enabled 는 건드리지 않는다 — 사용자 의도(enabled)와 자동 상태(circuit) 분리.
|
||
_CIRCUIT_OPEN_AFTER = 3
|
||
_CIRCUIT_DISABLE_AFTER = 10
|
||
_BACKOFF_BASE_HOURS = 6
|
||
_BACKOFF_CAP_HOURS = 48
|
||
_EMPTY_STREAK_ALERT = 8 # 6h 사이클 × 8 = 약 2일 연속 빈 피드 → 가시 경고
|
||
|
||
|
||
def _should_attempt(health: SourceHealth, now: datetime) -> bool:
|
||
"""circuit 상태에 따라 이번 사이클 fetch 여부 결정.
|
||
|
||
주의 (B-3 계약 ②, r5): 추후 relogin_requested 플래그 소비는 반드시 이
|
||
open-스킵 분기보다 *앞*에 두어야 한다 — open 이 스케줄 제외 형태가 되면
|
||
배치 경계가 안 와 플래그가 영원히 미소비(half-open 데드 버튼)가 된다.
|
||
"""
|
||
if health.circuit_state == "disabled":
|
||
return False
|
||
if health.circuit_state == "open" and health.last_error_at is not None:
|
||
over = max(health.consecutive_failures - _CIRCUIT_OPEN_AFTER, 0)
|
||
backoff_h = min(_BACKOFF_BASE_HOURS * (2 ** over), _BACKOFF_CAP_HOURS)
|
||
if now - health.last_error_at < timedelta(hours=backoff_h):
|
||
return False
|
||
return True
|
||
|
||
|
||
def _record_success(health: SourceHealth, items: int, not_modified: bool, now: datetime) -> None:
|
||
health.consecutive_failures = 0
|
||
health.total_fetches += 1
|
||
health.last_success_at = now
|
||
health.last_fetch_items = items
|
||
if health.circuit_state != "closed":
|
||
logger.info(f"[health] source={health.source_id} circuit {health.circuit_state}→closed")
|
||
health.circuit_state = "closed"
|
||
health.circuit_opened_at = None
|
||
# 빈 피드 streak: 304/해시동일은 정상 신호라 미집계, 200+entries 0 만 집계 (피드 부패 감시)
|
||
if not_modified:
|
||
pass
|
||
elif items == 0:
|
||
health.empty_streak += 1
|
||
if health.empty_streak >= _EMPTY_STREAK_ALERT:
|
||
logger.error(
|
||
f"[health] source={health.source_id} 빈 피드 {health.empty_streak}회 연속 "
|
||
f"— 피드 부패 의심 (RSSHub 류 라우트 깨짐 패턴)"
|
||
)
|
||
else:
|
||
health.empty_streak = 0
|
||
health.updated_at = now
|
||
|
||
|
||
def _record_failure(health: SourceHealth, error: str, now: datetime) -> None:
|
||
health.consecutive_failures += 1
|
||
health.total_fetches += 1
|
||
health.total_failures += 1
|
||
health.last_error = error[:500]
|
||
health.last_error_at = now
|
||
health.updated_at = now
|
||
cf = health.consecutive_failures
|
||
if cf > _CIRCUIT_DISABLE_AFTER and health.circuit_state != "disabled":
|
||
health.circuit_state = "disabled"
|
||
logger.error(
|
||
f"[health] source={health.source_id} 연속 실패 {cf}회 — circuit DISABLED "
|
||
f"(수집 제외, A-8 패널에서 수동 복구 필요)"
|
||
)
|
||
elif cf >= _CIRCUIT_OPEN_AFTER and health.circuit_state == "closed":
|
||
health.circuit_state = "open"
|
||
health.circuit_opened_at = now
|
||
logger.warning(f"[health] source={health.source_id} 연속 실패 {cf}회 — circuit open")
|
||
|
||
|
||
async def _get_or_create_health(session, source_id: int) -> SourceHealth:
|
||
result = await session.execute(
|
||
select(SourceHealth).where(SourceHealth.source_id == source_id)
|
||
)
|
||
health = result.scalars().first()
|
||
if health is None:
|
||
health = SourceHealth(source_id=source_id)
|
||
session.add(health)
|
||
await session.flush()
|
||
return health
|
||
|
||
|
||
# 수동 POST /api/news/collect 와 6h 스케줄 사이클의 동시 실행 차단 (단일 프로세스·단일
|
||
# 이벤트루프). 동시 진입 시 _get_or_create_health 가 같은 source_id 를 양쪽에서 INSERT
|
||
# → uq_source_health_source_id 위반 IntegrityError 로 사이클 전체가 죽는 경합의 원천 봉쇄.
|
||
_run_lock = asyncio.Lock()
|
||
|
||
|
||
async def run():
|
||
"""뉴스 수집 실행"""
|
||
async with _run_lock:
|
||
await _run_locked()
|
||
|
||
|
||
async def _run_locked():
|
||
now = datetime.now(timezone.utc)
|
||
async with async_session() as session:
|
||
result = await session.execute(
|
||
select(NewsSource).where(NewsSource.enabled == True)
|
||
)
|
||
sources = result.scalars().all()
|
||
|
||
if not sources:
|
||
logger.info("활성화된 뉴스 소스 없음")
|
||
return
|
||
|
||
total = 0
|
||
for source in sources:
|
||
health = await _get_or_create_health(session, source.id)
|
||
if not _should_attempt(health, now):
|
||
logger.info(f"[{source.name}] circuit {health.circuit_state} — 이번 사이클 skip")
|
||
continue
|
||
try:
|
||
if source.feed_type == "api":
|
||
count, status = await _fetch_api(session, source)
|
||
else:
|
||
count, status = await _fetch_rss(session, source)
|
||
|
||
source.last_fetched_at = datetime.now(timezone.utc)
|
||
_record_success(health, count, status == "not_modified", now)
|
||
total += count
|
||
except Exception as e:
|
||
logger.error(f"[{source.name}] 수집 실패: {e}")
|
||
source.last_fetched_at = datetime.now(timezone.utc)
|
||
_record_failure(health, str(e) or repr(e), now)
|
||
|
||
await session.commit()
|
||
logger.info(f"뉴스 수집 완료: {total}건 신규")
|
||
|
||
|
||
MAX_RESPONSE_SIZE = 5 * 1024 * 1024 # 5MB
|
||
ALLOWED_CONTENT_TYPES = ("application/rss+xml", "application/atom+xml",
|
||
"application/xml", "text/xml")
|
||
|
||
|
||
async def _is_portal_duplicate(session, title: str) -> bool:
|
||
"""A-6 2차 dedup: 포털 전재본 vs 원본이 다른 URL 로 이중 적재되는 케이스.
|
||
|
||
보조 키 = 제목 + 최근 3일 (다른 소스/다른 URL 이므로 1차 키로 안 잡힘).
|
||
범용 제목 오탐 방지: 12자 미만 제목은 비적용. skip 은 전부 로그 (silent 누락 회피).
|
||
"""
|
||
if len(title) < 12:
|
||
return False
|
||
cutoff = datetime.now(timezone.utc) - timedelta(days=3)
|
||
dup = await session.execute(
|
||
select(Document.id).where(
|
||
Document.title == title,
|
||
Document.source_channel == "news",
|
||
Document.file_format == "article",
|
||
Document.extracted_at >= cutoff,
|
||
).limit(1)
|
||
)
|
||
return dup.scalars().first() is not None
|
||
|
||
|
||
async def _enqueue_processing(session, doc: Document, source: NewsSource, pub_dt: datetime) -> None:
|
||
"""후속 단계 enqueue.
|
||
|
||
fulltext_policy='page' 소스는 'fulltext' stage 만 — summarize/embed/chunk 는
|
||
fulltext_worker 가 승격(또는 격하) 확정 후 enqueue (RSS 요약 선요약 → 풀텍스트
|
||
도착 시 summarize_worker 의 '이미 요약 있음 skip' 에 막히는 순서 함정 회피).
|
||
"""
|
||
if source.fulltext_policy == "page" and doc.edit_url:
|
||
await enqueue_stage(session, doc.id, "fulltext")
|
||
return
|
||
await enqueue_stage(session, doc.id, "summarize")
|
||
days_old = (datetime.now(timezone.utc) - pub_dt).days
|
||
if days_old <= 30:
|
||
await enqueue_stage(session, doc.id, "embed")
|
||
await enqueue_stage(session, doc.id, "chunk")
|
||
|
||
|
||
def _build_extract_meta(source: NewsSource, pub_dt: datetime) -> dict:
|
||
"""fulltext_worker / 패널이 쓰는 출처 메타 (documents 에 source FK 가 없어 여기 기록)."""
|
||
return {
|
||
"source_id": source.id,
|
||
"source_name": source.name,
|
||
"published_at": pub_dt.isoformat(),
|
||
}
|
||
|
||
|
||
async def _fetch_rss(session, source: NewsSource) -> tuple[int, str]:
|
||
"""RSS 피드 수집 — redirect 재검증 + 크기/content-type 제한 + 조건부 GET (A-1).
|
||
|
||
반환 (신규 건수, 상태). 상태 'not_modified' = 304 또는 콘텐츠 해시 동일.
|
||
소스 단위 실패는 FeedError raise — run() 이 health 실패로 기록.
|
||
"""
|
||
from urllib.parse import urljoin
|
||
from core.url_validator import validate_feed_url, HTTP_EXCEPTION_DOMAINS
|
||
|
||
# HTTP 허용 여부: 소스 도메인이 allowlist에 있으면 HTTP 허용
|
||
# SCMP처럼 HTTPS 원본이 HTTP로 redirect하는 경우도 커버
|
||
source_hostname = urlparse(source.feed_url).hostname
|
||
http_allowed = source_hostname in HTTP_EXCEPTION_DOMAINS
|
||
|
||
# 순수 HTTP 소스인데 allowlist에 없으면 차단
|
||
if source.feed_url.startswith("http://") and not http_allowed:
|
||
raise FeedError(f"HTTP 차단 (allowlist 미등록): {source_hostname}")
|
||
|
||
# fetch 전 URL 재검증 (등록 이후 DNS 변경 대비)
|
||
try:
|
||
validate_feed_url(source.feed_url, allow_http=http_allowed)
|
||
except ValueError as e:
|
||
raise FeedError(f"URL 검증 실패: {e}") from e
|
||
|
||
# A-1: 정직 UA + 조건부 GET — 서버가 준 워터마크를 받은 그대로 재전송
|
||
headers = {"User-Agent": CRAWL_UA}
|
||
if source.etag:
|
||
headers["If-None-Match"] = source.etag
|
||
if source.last_modified:
|
||
headers["If-Modified-Since"] = source.last_modified
|
||
|
||
async with httpx.AsyncClient(
|
||
timeout=10, follow_redirects=False, headers=headers
|
||
) as client:
|
||
resp = await client.get(source.feed_url)
|
||
|
||
# redirect 수동 처리 (최대 3회, 각 target 재검증)
|
||
# allowlist 도메인이면 redirect target의 HTTP도 허용
|
||
redirects = 0
|
||
while resp.is_redirect and redirects < 3:
|
||
location = resp.headers.get("location", "")
|
||
location = urljoin(str(resp.request.url), location)
|
||
try:
|
||
validate_feed_url(location, allow_http=http_allowed)
|
||
except ValueError as e:
|
||
raise FeedError(f"redirect target 차단: {e}") from e
|
||
resp = await client.get(location)
|
||
redirects += 1
|
||
if resp.is_redirect:
|
||
raise FeedError("redirect 3회 초과")
|
||
|
||
if resp.status_code == 304:
|
||
logger.info(f"[{source.name}] 304 Not Modified — 본문 미전송")
|
||
return 0, "not_modified"
|
||
|
||
resp.raise_for_status()
|
||
|
||
if len(resp.content) > MAX_RESPONSE_SIZE:
|
||
raise FeedError(f"응답 크기 초과: {len(resp.content)} bytes")
|
||
|
||
ct = resp.headers.get("content-type", "").lower()
|
||
if not any(t in ct for t in ALLOWED_CONTENT_TYPES):
|
||
raise FeedError(f"비정상 content-type: {ct}")
|
||
|
||
# A-1: 콘텐츠 해시 변경감지 (CDN 의 ETag 회전 대비 병행) — 저장된 해시는 항상
|
||
# 파싱 검증을 통과한 응답의 것이므로 동일성 비교는 파싱 전에 안전
|
||
new_etag = resp.headers.get("etag")
|
||
new_last_modified = resp.headers.get("last-modified")
|
||
content_hash = hashlib.sha256(resp.content).hexdigest()
|
||
if source.feed_content_hash == content_hash:
|
||
logger.info(f"[{source.name}] 콘텐츠 해시 동일 — 파싱 skip")
|
||
return 0, "not_modified"
|
||
|
||
feed = feedparser.parse(resp.text)
|
||
if feed.bozo and not feed.entries:
|
||
raise FeedError(f"RSS 파싱 실패: {feed.bozo_exception}")
|
||
|
||
# A-1: 워터마크 영속은 파싱 검증 통과 후에만 — 부패(bozo) 응답의 ETag 를 저장하면
|
||
# 이후 304 로 영구 skip 되는 silent corruption 차단
|
||
if new_etag:
|
||
source.etag = new_etag
|
||
if new_last_modified:
|
||
source.last_modified = new_last_modified
|
||
source.feed_content_hash = content_hash
|
||
count = 0
|
||
|
||
for entry in feed.entries:
|
||
title = entry.get("title", "").strip()
|
||
if not title:
|
||
continue
|
||
|
||
summary = _clean_html(entry.get("summary", "") or entry.get("description", ""))
|
||
if not summary:
|
||
summary = title
|
||
|
||
# A-6: feed-full 소스만 피드 본문을 전문으로 신뢰 (truncate·광고 삽입이 흔해
|
||
# 일반 소스의 summary/content:encoded 를 전문으로 오인 저장 금지)
|
||
body = summary
|
||
is_feed_full = False
|
||
if source.fulltext_policy == "feed-full":
|
||
content_list = entry.get("content") or []
|
||
raw_body = content_list[0].get("value", "") if content_list else ""
|
||
full_body = _clean_html(raw_body or entry.get("summary", ""), max_len=None)
|
||
if len(full_body) > len(summary):
|
||
body = full_body
|
||
is_feed_full = True
|
||
|
||
link = entry.get("link", "")
|
||
published = entry.get("published_parsed") or entry.get("updated_parsed")
|
||
pub_dt = datetime(*published[:6], tzinfo=timezone.utc) if published else datetime.now(timezone.utc)
|
||
|
||
# 중복 체크 — 레거시 행은 raw URL 로 저장돼 있어 normalized/raw 양쪽 매칭.
|
||
# 교차 게시(같은 기사가 두 피드에 존재)로 2행 이상 매칭될 수 있어 first() 사용
|
||
# (scalar_one_or_none 은 MultipleResultsFound raise — 2026-06 BBC 수집 중단 원인).
|
||
article_id = _article_hash(title, pub_dt.strftime("%Y%m%d"), source.name)
|
||
normalized_url = _normalize_url(link)
|
||
|
||
existing = await session.execute(
|
||
select(Document).where(
|
||
(Document.file_hash == article_id) |
|
||
(Document.edit_url.in_([normalized_url, link]))
|
||
).limit(1)
|
||
)
|
||
if existing.scalars().first():
|
||
continue
|
||
|
||
# A-6 2차: 포털 전재 dedup (first-wins — 먼저 적재된 쪽이 정본)
|
||
if await _is_portal_duplicate(session, title):
|
||
logger.info(f"[{source.name}] portal-dup skip: {title[:60]}")
|
||
continue
|
||
|
||
category = _normalize_category(source.category or "")
|
||
source_short = source.name.split(" ")[0] # "경향신문 문화" → "경향신문"
|
||
|
||
doc = Document(
|
||
file_path=f"news/{source.name}/{article_id}",
|
||
file_hash=article_id,
|
||
file_format="article",
|
||
file_size=len(body.encode()),
|
||
file_type="note",
|
||
title=title,
|
||
extracted_text=f"{title}\n\n{body}",
|
||
extracted_at=datetime.now(timezone.utc),
|
||
extractor_version="rss-feed-full" if is_feed_full else "rss",
|
||
# article = 텍스트 네이티브(본문=extracted_text). markdown 단계 미enqueue 라
|
||
# 기본값 'pending' 이면 영구 비수렴 → backlog 지표 오염 + md_status_pending partial
|
||
# 인덱스 비대. 생성 시점에 terminal 'skipped' 로 명시(변환 비대상).
|
||
# fulltext_policy='page' 소스는 fulltext_worker 가 승격 시 success 로 갱신.
|
||
md_status="skipped",
|
||
md_extraction_error="news article: 텍스트 네이티브, markdown 변환 비대상",
|
||
source_channel="news",
|
||
data_origin="external",
|
||
# 조회와 동일하게 정규화해 저장 — raw(tracking param 포함) 저장 시 URL dedup 무력화
|
||
edit_url=normalized_url,
|
||
review_status="approved",
|
||
ai_domain="News",
|
||
ai_sub_group=source_short,
|
||
ai_tags=[f"News/{source_short}/{category}"],
|
||
extract_meta=_build_extract_meta(source, pub_dt),
|
||
)
|
||
session.add(doc)
|
||
await session.flush()
|
||
|
||
# summarize + embed + chunk 등록 (classify 불필요).
|
||
# page 정책 소스는 fulltext 만 — 후속은 fulltext_worker 가 확정 후 enqueue.
|
||
await _enqueue_processing(session, doc, source, pub_dt)
|
||
|
||
count += 1
|
||
|
||
logger.info(f"[{source.name}] RSS → {count}건 수집")
|
||
return count, "ok"
|
||
|
||
|
||
async def _fetch_api(session, source: NewsSource) -> tuple[int, str]:
|
||
"""NYT API 수집 — 키 마스킹 + health degradation"""
|
||
import os
|
||
nyt_key = os.getenv("NYT_API_KEY", "")
|
||
if not nyt_key:
|
||
raise FeedError("NYT_API_KEY 미설정 — US 뉴스 수집 불가")
|
||
|
||
try:
|
||
async with httpx.AsyncClient(timeout=10) as client:
|
||
resp = await client.get(
|
||
f"https://api.nytimes.com/svc/topstories/v2/{source.category or 'world'}.json",
|
||
params={"api-key": nyt_key},
|
||
)
|
||
resp.raise_for_status()
|
||
except httpx.HTTPStatusError as e:
|
||
# 쿼리스트링(api-key 포함) 제거 — path까지만 로깅
|
||
safe_url = str(e.request.url).split("?")[0]
|
||
raise FeedError(f"NYT API 실패: {e.response.status_code} @ {safe_url}") from e
|
||
except httpx.RequestError as e:
|
||
safe_url = str(e.request.url).split("?")[0] if e.request else "unknown"
|
||
raise FeedError(f"NYT API 연결 실패: {safe_url}") from e
|
||
|
||
data = resp.json()
|
||
count = 0
|
||
|
||
for article in data.get("results", []):
|
||
title = article.get("title", "").strip()
|
||
if not title:
|
||
continue
|
||
|
||
summary = _clean_html(article.get("abstract", ""))
|
||
if not summary:
|
||
summary = title
|
||
|
||
link = article.get("url", "")
|
||
pub_str = article.get("published_date", "")
|
||
try:
|
||
pub_dt = datetime.fromisoformat(pub_str.replace("Z", "+00:00"))
|
||
except (ValueError, AttributeError):
|
||
pub_dt = datetime.now(timezone.utc)
|
||
|
||
article_id = _article_hash(title, pub_dt.strftime("%Y%m%d"), source.name)
|
||
normalized_url = _normalize_url(link)
|
||
|
||
# RSS 수집부와 동일: 레거시 raw URL + 교차 게시 다중 매칭 내성 (first)
|
||
existing = await session.execute(
|
||
select(Document).where(
|
||
(Document.file_hash == article_id) |
|
||
(Document.edit_url.in_([normalized_url, link]))
|
||
).limit(1)
|
||
)
|
||
if existing.scalars().first():
|
||
continue
|
||
|
||
if await _is_portal_duplicate(session, title):
|
||
logger.info(f"[{source.name}] portal-dup skip: {title[:60]}")
|
||
continue
|
||
|
||
category = _normalize_category(article.get("section", source.category or ""))
|
||
source_short = source.name.split(" ")[0]
|
||
|
||
doc = Document(
|
||
file_path=f"news/{source.name}/{article_id}",
|
||
file_hash=article_id,
|
||
file_format="article",
|
||
file_size=len(summary.encode()),
|
||
file_type="note",
|
||
title=title,
|
||
extracted_text=f"{title}\n\n{summary}",
|
||
extracted_at=datetime.now(timezone.utc),
|
||
extractor_version="nyt_api",
|
||
# article = 텍스트 네이티브(본문=extracted_text). markdown 단계 미enqueue 라
|
||
# 기본값 'pending' 이면 영구 비수렴 → backlog 지표 오염 + md_status_pending partial
|
||
# 인덱스 비대. 생성 시점에 terminal 'skipped' 로 명시(변환 비대상).
|
||
md_status="skipped",
|
||
md_extraction_error="news article: 텍스트 네이티브, markdown 변환 비대상",
|
||
source_channel="news",
|
||
data_origin="external",
|
||
edit_url=normalized_url,
|
||
review_status="approved",
|
||
ai_domain="News",
|
||
ai_sub_group=source_short,
|
||
ai_tags=[f"News/{source_short}/{category}"],
|
||
extract_meta=_build_extract_meta(source, pub_dt),
|
||
)
|
||
session.add(doc)
|
||
await session.flush()
|
||
|
||
await _enqueue_processing(session, doc, source, pub_dt)
|
||
|
||
count += 1
|
||
|
||
logger.info(f"[{source.name}] API → {count}건 수집")
|
||
return count, "ok"
|