catalystmind 님의 블로그

Playwright와 Trafilatura를 활용한 JavaScript 기반 웹사이트 추출

catalystmind — Fri, 13 Jun 2025 23:50:11 +0900

TL;DR

기존 Trafilatura + Requests 조합은 JavaScript 기반 사이트에서 본문 추출 한계 발생
Playwright 도입 후 requests에서 실패한 biz.chosun.com 등은 100% 추출 성공
www.msn.com 등 일부 사이트는 여전히 추출 실패, 특화된 로직 필요
처리 속도는 requests 대비 평균 10배 감소하여 성능 최적화 필요
Playwright 병렬화를 통한 처리 시간 단축이 핵심 개선 과제

향후 개선 방향

개선 방향 ① 처리 시간 단축을 위한 Playwright 병렬화 필요
개선 방향 ② msn.com 등 반복 실패 사이트에 특화된 추출 로직 필요

trafilatura+ requests를 이용하여 약 80%의 기사 본문 추출에 성공하였다. 실패한 20%를 분석한 결과, 특정 도메인에서는 본문 추출이 100% 실패하였다. 하지만, 우리가 실제 브라우저에서 접속하면 모든 것이 정상으로 보인다. 이는 왜 그럴까? 이는 JavaScript로 만들어진 웹사이트의 특징으로 JavaScript가 실행된 후에 실제 내용이 나타나는 방식이기 때문이다. 따라서, 이런 웹사이트에서 본문을 추출하려면 실제 브라우저를 열고 웹사이트로 이동하도록 자동화해야 한다.

requests + trafilatura 조합 실패 사례 분석

문제 도메인 집중도

biz.chosun.com 100% (62건)
www.msn.com 100% (23건)
기타 도메인 약 10% (9건)

프로토콜 분석

HTTPS 사이트 85건 (90.4%)
HTTP 사이트 9건 (9.6%)
평균 처리시간 1.45초

오류 유형별 분석

콘텐츠 추출 실패

페이지 구조 변경, JS 렌더링, 또는 동적 로딩으로 인한 실패

92건

연결 타임아웃

서버 응답 지연 (antnews.org)

1건

서비스 이용불가

503 에러 - 서버 일시적 장애

1건

Playwright란?

Playwright는 마이크로소프트에서 개발한 웹 브라우저 자동화 도구로, 사람이 직접 웹브라우저에서 하는 모든 행동을 코드로 자동화할 수 있게 해주는 프로그램이다.

무엇을 할 수 있나?

실제 브라우저를 열어서 웹페이지에 접속하고, 버튼을 클릭하고, 텍스트를 입력하고, 스크롤을 내리는 등 사용자가 할 수 있는 모든 행동을 자동으로 수행할 수 있다. 간단한 작업은 Powerautomate로도 가능하지만, 조금만 복잡해져도 금방 한계가 드러난다.

⭐ 왜 유용한가?

⚙️ JavaScript 처리: 요즘 웹사이트는 대부분 JavaScript로 동적으로 콘텐츠를 로딩한다. 이런 웹사이트는 초기 HTML은 빈 껍데기만 제공하고, JavaScript가 실행된 후에야 실제 내용이 나타나는 방식이므로, requests로는 빈 껍데기만 가져올 뿐이다. 반면, Playwright는 이런 복잡한 웹사이트도 완벽하게 처리할 수 있다.
실제 브라우저 환경: Chrome, Firefox, Safari 등 실제 브라우저를 사용하므로 웹사이트가 정확히 어떻게 보이고 동작하는지 파악할 수 있다. 특히, 문제가 발생하면 어디서 문제가 발생하는지 정확하게 확인할 수 있다.
안정성: 페이지가 완전히 로딩될 때까지 자동으로 기다리고, 오류가 발생하면 재시도하는 등 안정적으로 작동한다.

주요 활용 분야

️ 웹 스크래핑: 복잡한 웹사이트에서 데이터를 수집할 때
자동화 테스트: 웹사이트가 제대로 작동하는지 자동으로 검사
반복 작업 자동화: 매일 해야 하는 웹 작업을 자동화
모니터링: 웹사이트 상태를 주기적으로 확인

⚠️ 단점

속도가 상대적으로 느리고(실제 브라우저를 실행하기 때문), 설치 파일이 크며(수백 MB), 리소스를 많이 사용한다. 따라서, Playwright는 "진짜 브라우저에서 복잡한 작업을 자동화해야 할 때" 사용하는 강력한 도구라고 보면 된다.

Playwright vs Requests 비교표

항목	Playwright	Requests
주요 목적	브라우저 자동화 및 렌더링된 콘텐츠 제어	HTTP 요청으로 정적 데이터 수집
⚙️ JavaScript 처리	완전 지원	지원하지 않음
️ UI 상호작용	클릭, 입력, 스크롤	불가능
⚡ 처리 속도	느림	매우 빠름
설치 크기	큼 (수백 MB)	가벼움

playwright와 trafilatura를 결합한 기본 사용법

가장 많은 실패건수를 기록하고 있는 biz.chosun.com 웹사이트를 테스트 해보기로 했다. requests에 해당하는 부분을 playwright로 바꿔서 html을 추출하는 코드로 변경했다. 테스트 결과, 성공적으로 본문이 추출됨을 확인했다.

import asyncio
from playwright.sync_api import sync_playwright
import trafilatura
from trafilatura.metadata import extract_metadata

# 대상 URL 설정
url = "https://biz.chosun.com/stock/c-biz_bot/2025/05/20/ANYFOCJLKBURJBPW4ZXRNUSKLE"

# HTML 다운로드 (Playwright 사용)
def fetch_with_playwright(target_url):
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
        )
        page = browser.new_page()
        page.goto(target_url, wait_until='domcontentloaded', timeout=30000)
        page.wait_for_timeout(3000)
        content = page.content()
        browser.close()
        return content

# HTML 가져오기
downloaded = fetch_with_playwright(url)

# 메타데이터 및 본문 텍스트 추출
metadata = extract_metadata(downloaded)
text = trafilatura.extract(downloaded, output_format='txt', include_comments=False, favor_precision=True)

# 결과 출력
print(f"  제목: {metadata.title}")
print(f"  날짜: {metadata.date}")
print(f"  본문:\n{text}")

️ 실행결과

⚠️ 주의 사항: Jupyter Notebook이 이미 asyncio 이벤트 루프를 실행 중이기 때문에, Jupyter에서는 비동기 버전을 사용해야 한다. (Jupyter Notebook 수정된 코드는 아래를 참고)

import asyncio
from playwright.async_api import async_playwright
import trafilatura
from trafilatura.metadata import extract_metadata

# 대상 URL
url = "https://biz.chosun.com/stock/c-biz_bot/2025/05/20/ANYFOCJLKBURJBPW4ZXRNUSKLE"

# Playwright로 HTML 가져오기 (비동기)
async def fetch_with_playwright(target_url):
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        context = await browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
        )
        page = await browser.new_page()        
        await page.goto(target_url, wait_until='domcontentloaded', timeout=30000)
        await page.wait_for_timeout(3000)
        content = await page.content()
        await browser.close()
        return content

# Jupyter에서는 asyncio.run() 대신 nest_asyncio 사용 필요
import nest_asyncio
nest_asyncio.apply()

# 실행 및 결과 추출
downloaded = asyncio.get_event_loop().run_until_complete(fetch_with_playwright(url))
metadata = extract_metadata(downloaded)
text = trafilatura.extract(downloaded, output_format='txt', include_comments=False, favor_precision=True)

# 결과 출력
print(f"  제목: {metadata.title}")
print(f"  날짜: {metadata.date}")
print(f"  본문:\n{text}")

Trafilatura - Playwright 조합의 성능 평가

성능 평가를 위해, Trafilatura - Requests 조합에서 실패한 94개의 웹사이트를 그대로 사용했다. 성능 평가를 위한 최종 코드는 아래와 같이 작성하였다.

playwright Batch Processor (w/ Trafilatura) 펼치기


import pandas as pd
import trafilatura
from trafilatura.metadata import extract_metadata
from playwright.sync_api import sync_playwright
import time
from datetime import datetime
import csv
from typing import List, Optional


def fetch_html_with_playwright(url: str, timeout: int = 30000) -> dict:
    """
    Playwright로 HTML 다운로드하는 함수
    """
    result = {
        'url': url,
        'html': '',
        'success': False,
        'error': None,
        'method_used': 'playwright'
    }

    try:
        with sync_playwright() as p:
            browser = p.chromium.launch(headless=True)
            context = browser.new_context(
                user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
            )
            page = browser.new_page()
            page.goto(url, wait_until='domcontentloaded', timeout=timeout)
            # 페이지 로딩 대기 (필요시)
            page.wait_for_timeout(3000)
            content = page.content()
            browser.close()
            
            result['html'] = content
            result['success'] = True

    except Exception as e:
        result['error'] = str(e)

    return result


def process_single_url(url, index, total_urls):
    """단일 URL 처리 함수"""
    start_time = time.time()
    result = {
        "index": index,
        "url": url,
        "status": "failed",
        "title": None,
        "date": None,
        "content": None,
        "processing_time": 0,
        "error_message": None,
    }
    
    try:
        print(f"Processing URL {index + 1}/{total_urls}: {url[:60]}...")
        
        # HTML 다운로드 (Playwright 사용)
        html_result = fetch_html_with_playwright(url)
        
        if html_result['success']:
            html_content = html_result['html']
            
            # trafilatura로 메타데이터 추출
            metadata = trafilatura.extract_metadata(html_content)
            
            # trafilatura로 본문 추출
            text = trafilatura.extract(
                html_content,
                output_format="txt",
                include_comments=False,
                favor_precision=True,
            )
            
            if text and len(text.strip()) > 0:
                result.update({
                    "status": "success",
                    "title": metadata.title if metadata and metadata.title else "No title",
                    "date": str(metadata.date) if metadata and metadata.date else "No date",
                    "content": text,
                })
            else:
                result["error_message"] = "Empty content extracted"
        else:
            result["error_message"] = f"Failed to download page: {html_result['error']}"
            
    except Exception as e:
        result["error_message"] = str(e)
    
    # 처리 시간 계산
    processing_time = time.time() - start_time
    result["processing_time"] = processing_time
    
    return result


def save_results_to_csv(results, input_file_path=None, output_file=None):
    """결과를 CSV 파일로 저장"""
    import os

    # 파일명이 지정되지 않으면 현재 시간을 포함한 파일명 생성
    if output_file is None:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"url_processing_results_playwright_{timestamp}.csv"
        
        # 입력 파일과 같은 디렉토리에 저장
        if input_file_path and os.path.exists(input_file_path):
            input_dir = os.path.dirname(input_file_path)
            output_file = os.path.join(input_dir, filename)
        else:
            # 입력 파일 경로가 없으면 현재 디렉토리에 저장
            output_file = filename

    try:
        with open(output_file, "w", newline="", encoding="utf-8") as csvfile:
            fieldnames = [
                "index",
                "url",
                "status",
                "title",
                "date",
                "content",
                "processing_time",
                "error_message",
            ]
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

            writer.writeheader()
            for result in results:
                writer.writerow(result)

        print(f"✅ 결과가 '{output_file}' 파일에 저장되었습니다.")
        return output_file  # 실제 저장된 파일명 반환

    except Exception as e:
        print(f"❌ 결과 저장 실패: {e}")
        return None


def print_summary(results, total_time, skipped_count=0):
    """처리 결과 요약 출력"""
    total_urls = len(results)
    successful_count = sum(1 for r in results if r["status"] == "success")
    failed_count = total_urls - successful_count
    processing_times = [r["processing_time"] for r in results]

    print("\n" + "=" * 7 + " SUMMARY " + "=" * 7)
    print(f"Total URLs processed: {total_urls}")
    print("Workers used: 1")  # 단일 스레드 처리
    print(f"Successfully decoded: {successful_count} ({successful_count/total_urls*100:.1f}%)")
    print(f"Failed to decode: {failed_count} ({failed_count/total_urls*100:.1f}%)")
    print(f"Skipped (Google News URLs): {skipped_count} ({skipped_count/(total_urls + skipped_count)*100:.1f}%)")

    if processing_times:
        avg_time = sum(processing_times) / len(processing_times)

        print("\n" + "-" * 5 + " TIMING INFORMATION " + "-" * 5)
        print(f"Total processing time: {int(total_time//60)}:{total_time%60:05.2f}")
        print(f"Average processing time per URL: {avg_time:.2f} seconds")
        print(f"Fastest URL processing time: {min(processing_times):.2f} seconds")
        print(f"Slowest URL processing time: {max(processing_times):.2f} seconds")

    print("\nProcess completed successfully. Results saved to CSV file.")


def process_urls_from_csv(csv_file_path, url_column="url", status_column="status"):
    """CSV 파일에서 status가 'failed'인 URL들을 읽어서 순차 처리"""

    print("=" * 50)
    print("  URL 배치 처리 시작 (Playwright - Failed URLs만)")
    print("=" * 50)

    # CSV 파일 읽기
    try:
        df = pd.read_csv(csv_file_path)
        print(f"  CSV 파일 컬럼들: {list(df.columns)}")
        print(f"  총 행 수: {len(df)}")

        # 필요한 컬럼 존재 확인
        if url_column not in df.columns:
            raise ValueError(f"Column '{url_column}' not found in CSV file")
        if status_column not in df.columns:
            raise ValueError(f"Column '{status_column}' not found in CSV file")

        # status가 'failed'인 행들만 필터링
        failed_df = df[df[status_column] == 'failed']
        print(f"  전체 행 수: {len(df)}")
        print(f"  status가 'failed'인 행 수: {len(failed_df)}")

        if len(failed_df) == 0:
            print("⚠️ status가 'failed'인 URL이 없습니다.")
            return None, None

        # failed URL들 추출 (NULL 값 제외)
        all_urls = failed_df[url_column].dropna().tolist()
        print(f"  '{url_column}' 컬럼의 NULL이 아닌 값 개수: {len(all_urls)}")
        
        if all_urls:
            print(f"  첫 번째 URL 샘플: {all_urls[0]}")

        # news.google.com이 포함되지 않은 URL만 필터링
        urls = [url for url in all_urls if "news.google.com" not in str(url)]

        total_urls = len(urls)
        skipped_urls = len(all_urls) - total_urls

        print(f"  failed 상태의 전체 URL: {len(all_urls)}개")
        print(f"  처리 대상 URL: {total_urls}개")
        print(f"  건너뛴 URL (Google News URLs): {skipped_urls}개")

        if urls:
            print(f"  첫 번째 처리 대상 URL 샘플: {urls[0]}")

        print("-" * 30)

    except Exception as e:
        print(f"❌ CSV 파일 읽기 실패: {e}")
        return None

    total_start_time = time.time()
    results = []
    successful_count = 0
    failed_count = 0

    for i, url in enumerate(urls):
        result = process_single_url(url, i, total_urls)
        results.append(result)

        if result["status"] == "success":
            successful_count += 1
        else:
            failed_count += 1

        if (i + 1) % 10 == 0 or (i + 1) == total_urls:
            print(
                f"진행: {i + 1}/{total_urls} "
                f"({(i + 1)/total_urls*100:.1f}%) "
                f"성공: {successful_count}, 실패: {failed_count}"
            )

    total_processing_time = time.time() - total_start_time
    print_summary(results, total_processing_time, skipped_urls)

    saved_file = save_results_to_csv(results, input_file_path=csv_file_path)
    return results, saved_file


def main():
    import sys
    import os
    
    # 명령줄 인자로 파일명을 받은 경우
    if len(sys.argv) > 1:
        csv_file_path = sys.argv[1]
    else:
        # 대화형으로 파일명 입력받기
        print("=" * 50)
        print("  CSV 파일 입력")
        print("=" * 50)
        
        while True:
            csv_file_path = input("처리할 CSV 파일 경로를 입력하세요: ").strip()
            
            # 따옴표 제거 (드래그앤드롭으로 붙여넣을 때 따옴표가 붙는 경우)
            csv_file_path = csv_file_path.strip('"').strip("'")
            
            # 파일 존재 여부 확인
            if os.path.exists(csv_file_path):
                break
            else:
                print(f"❌ 파일을 찾을 수 없습니다: {csv_file_path}")
                print("다시 입력해주세요.\n")
    
    # 파일 존재 여부 최종 확인
    if not os.path.exists(csv_file_path):
        print(f"❌ 파일을 찾을 수 없습니다: {csv_file_path}")
        return
    
    print(f"  처리할 파일: {csv_file_path}")
    
    # 컬럼명 설정 (필요시 여기서 변경 가능)
    url_column = "url"
    status_column = "status"
    
    # 컬럼명을 사용자가 지정하고 싶은 경우
    while True:
        change_columns = input(f"\nURL 컬럼명 (현재: '{url_column}')과 Status 컬럼명 (현재: '{status_column}')을 변경하시겠습니까? (y/n): ").strip().lower()
        
        if change_columns in ['y', 'yes']:
            url_column = input(f"URL 컬럼명을 입력하세요 (기본값: {url_column}): ").strip() or url_column
            status_column = input(f"Status 컬럼명을 입력하세요 (기본값: {status_column}): ").strip() or status_column
            break
        elif change_columns in ['n', 'no']:
            break
        else:
            print("y 또는 n을 입력해주세요.")
    
    print(f"  사용할 컬럼: URL='{url_column}', Status='{status_column}'")
    
    # URL 처리 시작
    results, saved_file = process_urls_from_csv(csv_file_path, url_column=url_column, status_column=status_column)

    if results:
        print(f"\n  저장된 파일: {saved_file}")

        print("\n  처리 결과 샘플:")
        for i, result in enumerate(results[:3]):
            print(f"\n[{i+1}] {result['url'][:50]}...")
            print(f"    상태: {result['status']}")
            print(f"    제목: {result['title']}")
            print(f"    처리시간: {result['processing_time']:.2f}초")
            if result["status"] == "failed":
                print(f"    오류: {result['error_message']}")
    else:
        print("\n❌ 처리할 URL이 없거나 처리에 실패했습니다.")


if __name__ == "__main__":
    main()

️ 실행결과

성능 평가 및 결과

request는 0.61초에 하나의 웹사이트를 추출할 수 있지만, playwright를 이용한 브라우저 자동화는 평균 5.93초로 시간이 약 10배 가까이 증가하였다. 또한, 여전히 msn 웹사이트에 대해서는 추출이 100% 실패했다.

도메인별 성공률 분석

✅ 성공 도메인

biz.chosun.com

62/62 100%

biz.sbs.co.kr

4/4 100%

www.antnews.org

1/1 100%

www.medisobizanews.com

1/1 100%

❌ 실패/부분실패 도메인

www.msn.com

0/23 0%

www.newstong.co.kr

1/3 33.3%

❌ 실패 사이트 심층 분석

www.msn.com (23건 모두 실패)

실패 원인: Empty content extracted
분석: 동적 콘텐츠 로딩 또는 봇 차단 가능성

www.newstong.co.kr (2건 실패)

실패 원인: Empty content extracted
분석: 일부 페이지의 구조적 차이점 존재

⏱️ 처리 시간 분포

24.5%

4.3%

14.9%

31.9%

17.0%

7.4%

3-4초

4-5초

5-6초

6-7초

7-8초

8초+

주요 인사이트 및 개선 방안

조선비즈 가장 안정적

100% 성공률로 가장 신뢰할 수 있는 스크래핑 대상

처리 시간 6-7초 집중

전체의 31.9%가 6-7초 구간에 분포하며 안정적 성능

MSN 사이트 스크래핑 불가능

봇 차단 또는 JavaScript 의존적 콘텐츠 로딩으로 완전 실패

콘텐츠 추출 로직 개선 필요

모든 실패가 "Empty content extracted" - 추출 방식 재검토 요구

마치며

Playwright와 Trafilatura를 결합한 웹 스크래핑 방식으로 기존 requests 기반 방법을 개선하였다. 94개 실패 URL을 대상으로 테스트한 결과, 69개(73.4%)가 성공하여 상당한 개선을 보였다. 특히 biz.chosun.com은 100% 성공률을 달성했으나, 여전히 msn 웹사이트는 실패했다. 처리 시간은 평균 5.93초로 requests 대비 약 10배 증가했지만, JavaScript 기반 동적 웹사이트에서 안정적인 콘텐츠 추출이 가능해졌다.

분석 결과 두 가지 주요 개선사항이 도출되었습니다: 첫째, 처리 시간 단축을 위한 병렬 처리 도입이 필요하며, 둘째, MSN 사이트에 특화된 콘텐츠 추출 로직이 필요하다. 다음글에는 첫번째 문제인 처리 시간 닥축을 위한 병렬 처리 도입에 대해서 다룬다.

Trafilatura - requsets - 병렬처리로 시간 단축하기

catalystmind — Sat, 7 Jun 2025 21:20:54 +0900

TL;DR

Worker 5개 병렬 처리로 웹 스크래핑 시간을 5분→2분(60% 단축), 처리량 2.5배 향상 달성
이론상 5배 개선 대비 실제 2.5배는 50% 효율이나, 웹 스크래핑 분야에서 준수한 수준임
병목 원인은 네트워크 I/O, 서버 rate limiting, 시스템 오버헤드 등으로 예상됨
실용적 가치로 일일 처리량 2.5배 증가, 개발 시간 60% 절약, 서비스 응답성 60% 향상 효과 예상

requsets의 병렬화 필요성

trafilatura와 requests를 활용하여 500개의 기사를 순차적으로 처리할 경우, 기사 하나당 평균 처리 시간은 0.6초로 전체 처리시간은 약 5분이 소요되었다. 분당 100개의 웹사이트 처리하는 것이 느리지는 않으나, 시간을 더 단축해보기로 했다. request도 I/O 바운드 작업이기에 requests + threadpoolexecutor 조합으로 병렬화를 시도했다. (병렬화에 대한 내용은 이전 글을 참고)

Googlenewsdecoder - 병렬처리로 시간 단축하기

TL;DR GoogleNewsDecoder는 I/O 바운드 작업으로 병렬 처리에 적합한 특성을 가짐 Python의 concurrent.futures 라이브러리를 활용해 ThreadPoolExecutor 기반의 병렬 처리 시스템 구현 submit()과 as_completed() 메서드를

catalystmind.tistory.com

requsets와 ThreadPoolExecutor의 통합

requsets는 URL 요청으로 이루어진 I/O 바운드 작업이므로 멀티스레드를 이용한 병렬화 효과가 뛰어나다. 병렬처리를 위한 파이썬 코드는 이전 코드를 조합하여 작성하였다.(전체 파이썬 스크립트 및 사용법은 아래를 참고)

request Batch Processor (w/ Trafilatura) 펼치기


import pandas as pd
import trafilatura
from trafilatura.metadata import extract_metadata
import requests
import time
from datetime import datetime, timedelta
import csv
import argparse
import concurrent.futures
from typing import List, Optional
import os


def guess_best_decode(data: bytes, encodings: List[str]) -> str:
    """Pick the decoding that yields the most Hangul characters."""
    best_text: Optional[str] = None
    best_score = -1
    for enc in encodings:
        if not enc:
            continue
        try:
            text = data.decode(enc, errors="replace")
        except LookupError:
            continue
        # Score by Hangul character count
        score = sum(0xAC00 <= ord(ch) <= 0xD7A3 for ch in text)
        if score > best_score:
            best_text, best_score = text, score
        # Early exit if score is very high (heuristic)
        if score > 10:
            break
    if best_text is None:
        best_text = data.decode("utf-8", errors="replace")
    return best_text

def fetch_html_with_requests(url: str, timeout: int = 10) -> dict:
    """
    requests로 HTML만 다운로드하는 함수 (본문 추출은 별도로 수행)
    guess_best_decode를 활용한 강력한 인코딩 자동 보정
    """
    result = {
        'url': url,
        'html': '',
        'success': False,
        'error': None,
        'method_used': 'requests_only'
    }

    try:
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36'
        }
        response = requests.get(url, headers=headers, timeout=timeout)
        response.raise_for_status()

        # ✅ guess_best_decode를 통해 인코딩 복원
        candidates = [
            response.encoding,
            response.apparent_encoding,
            'utf-8',
            'euc-kr',
            'cp949'
        ]
        result['html'] = guess_best_decode(response.content, candidates)
        result['success'] = True

    except Exception as e:
        result['error'] = str(e)

    return result

def process_single_url(url, index=None):
    """단일 URL 처리 함수 - 병렬처리에 최적화"""
    start_time = time.time()
    result = {
        "index": index,
        "url": url,
        "status": "failed",
        "title": None,
        "date": None,
        "content": None,
        "processing_time": 0,
        "error_message": None,
    }
    
    try:
        # HTML 다운로드
        html_result = fetch_html_with_requests(url)
        
        if html_result['success']:
            html_content = html_result['html']
            
            # trafilatura로 메타데이터 추출
            metadata = trafilatura.extract_metadata(html_content)
            
            # trafilatura로 본문 추출
            text = trafilatura.extract(
                html_content,
                output_format="txt",
                include_comments=False,
                favor_precision=True,
            )
            
            if text and len(text.strip()) > 0:
                result.update({
                    "status": "success",
                    "title": metadata.title if metadata and metadata.title else "No title",
                    "date": str(metadata.date) if metadata and metadata.date else "No date",
                    "content": text[:200] + "..." if len(text) > 200 else text,
                })
            else:
                result["error_message"] = "Empty content extracted"
        else:
            result["error_message"] = f"Failed to download page: {html_result['error']}"
            
    except Exception as e:
        result["error_message"] = str(e)
    
    # 처리 시간 계산
    processing_time = time.time() - start_time
    result["processing_time"] = processing_time
    
    return result


def save_results_to_csv(results, output_file=None):
    """결과를 CSV 파일로 저장"""
    # 파일명이 지정되지 않으면 현재 시간을 포함한 파일명 생성
    if output_file is None:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        output_file = f"url_processing_results_{timestamp}.csv"

    try:
        with open(output_file, "w", newline="", encoding="utf-8") as csvfile:
            fieldnames = [
                "index",
                "url",
                "status",
                "title",
                "date",
                "content",
                "processing_time",
                "error_message",
            ]
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

            writer.writeheader()
            for result in results:
                writer.writerow(result)

        print(f"✅ 결과가 '{output_file}' 파일에 저장되었습니다.")
        return output_file  # 실제 저장된 파일명 반환

    except Exception as e:
        print(f"❌ 결과 저장 실패: {e}")
        return None


def print_summary(results, total_time, skipped_count=0, workers_used=1):
    """처리 결과 요약 출력"""
    total_urls = len(results)
    successful_count = sum(1 for r in results if r["status"] == "success")
    failed_count = total_urls - successful_count
    processing_times = [r["processing_time"] for r in results]

    # 시간 포맷팅 함수
    def format_time(seconds):
        if seconds < 60:
            return f"{seconds:.2f} seconds"
        else:
            return str(timedelta(seconds=round(seconds)))

    print("\n" + "=" * 7 + " SUMMARY " + "=" * 7)
    print(f"Total URLs processed: {total_urls}")
    print(f"Workers used: {workers_used} (Parallel processing: {'Enabled' if workers_used > 1 else 'Disabled'})")
    print(f"Successfully decoded: {successful_count} ({successful_count/total_urls*100:.1f}%)")
    print(f"Failed to decode: {failed_count} ({failed_count/total_urls*100:.1f}%)")
    print(f"Skipped (Google News URLs): {skipped_count} ({skipped_count/(total_urls + skipped_count)*100:.1f}%)")

    if processing_times:
        avg_time = sum(processing_times) / len(processing_times)

        print("\n" + "-" * 5 + " TIMING INFORMATION " + "-" * 5)
        print(f"Total processing time: {format_time(total_time)}")
        print(f"Average processing time per URL: {format_time(avg_time)}")
        print(f"Fastest URL processing time: {format_time(min(processing_times))}")
        print(f"Slowest URL processing time: {format_time(max(processing_times))}")

    print("\nProcess completed successfully. Results saved to CSV file.")


def process_urls_from_csv(csv_file_path, url_column="decoded_url", output_dir=None, 
                         batch_size=10, workers=1):
    """CSV 파일에서 URL들을 읽어서 병렬 처리"""

    print("=" * 50)
    print("  URL 배치 처리 시작")
    print("=" * 50)

    # CSV 파일 읽기
    try:
        df = pd.read_csv(csv_file_path)
        print(f"  CSV 파일 컬럼들: {list(df.columns)}")
        print(f"  총 행 수: {len(df)}")

        if url_column not in df.columns:
            raise ValueError(f"Column '{url_column}' not found in CSV file")

        print(f"  '{url_column}' 컬럼의 NULL이 아닌 값 개수: {df[url_column].notna().sum()}")

        all_urls = df[url_column].dropna().tolist()
        print(f"  첫 번째 URL 샘플: {all_urls[0] if all_urls else 'None'}")

        # news.google.com이 포함되지 않은 URL만 필터링
        urls = [url for url in all_urls if "news.google.com" not in str(url)]

        total_urls = len(urls)
        skipped_urls = len(all_urls) - total_urls

        print(f"  전체 URL: {len(all_urls)}개")
        print(f"  처리 대상 URL (decoded URLs): {total_urls}개")
        print(f"  건너뛴 URL (Google News URLs): {skipped_urls}개")
        print(f"  배치 크기: {batch_size}")
        print(f"  작업자 수: {workers} (병렬 처리: {'활성화' if workers > 1 else '비활성화'})")

        if urls:
            print(f"  첫 번째 디코딩된 URL 샘플: {urls[0]}")

        print("-" * 30)

    except Exception as e:
        print(f"❌ CSV 파일 읽기 실패: {e}")
        return None, None

    # 출력 파일 설정
    if output_dir is None:
        output_dir = os.path.dirname(csv_file_path) or '.'
    
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    input_filename = os.path.basename(csv_file_path).split('.')[0]
    output_filename = f"{input_filename}_processed_{timestamp}.csv"
    output_path = os.path.join(output_dir, output_filename)
    
    print(f"  결과 저장 경로: {output_path}")

    total_start_time = time.time()
    results = []
    completed = 0

    # 병렬 처리 사용 여부에 따라 처리 방식 결정
    if workers > 1:
        print(f"  병렬 처리 모드로 실행 중...")
        
        # URL 배치로 나누기 (한 번에 batch_size만큼 병렬 처리)
        for batch_start in range(0, total_urls, batch_size):
            batch_end = min(batch_start + batch_size, total_urls)
            batch_urls = urls[batch_start:batch_end]
            
            print(f"처리 중: URLs {batch_start+1}-{batch_end} of {total_urls}...")
            
            # 병렬 처리 실행
            with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
                # URL을 병렬로 처리 (인덱스도 함께 전달)
                future_to_data = {
                    executor.submit(process_single_url, url, batch_start + i): (url, batch_start + i) 
                    for i, url in enumerate(batch_urls)
                }
                
                # 결과 수집
                for future in concurrent.futures.as_completed(future_to_data):
                    result = future.result()
                    results.append(result)
                    completed += 1
                    
                    # 진행 상황 표시 (10개마다 또는 배치 완료 시)
                    if completed % 10 == 0 or completed == total_urls:
                        successful_in_batch = sum(1 for r in results[-len(batch_urls):] if r["status"] == "success")
                        print(f"진행: {completed}/{total_urls} ({completed/total_urls*100:.1f}%) "
                              f"배치 성공: {successful_in_batch}/{len(batch_urls)}")
            
            # 현재까지의 결과를 CSV 파일로 저장
            save_results_to_csv(results, output_path)
            print(f"  {len(results)}개 결과 저장 완료")
            
    else:
        print(f"  순차 처리 모드로 실행 중...")
        
        # 직렬 처리 사용 (기존 방식)
        for i, url in enumerate(urls):
            if i % 10 == 0 or i == total_urls - 1:
                print(f"처리 중: URL {i+1}/{total_urls}...")
            
            # 단일 URL 처리
            result = process_single_url(url, i)
            results.append(result)
            completed += 1
            
            # batch_size마다 중간 결과 저장
            if (i + 1) % batch_size == 0 or i == total_urls - 1:
                save_results_to_csv(results, output_path)
                successful_count = sum(1 for r in results if r["status"] == "success")
                print(f"진행: {completed}/{total_urls} ({completed/total_urls*100:.1f}%) "
                      f"성공: {successful_count}, 실패: {completed-successful_count}")

    total_processing_time = time.time() - total_start_time
    print_summary(results, total_processing_time, skipped_urls, workers)

    return results, output_path


def main():
    # 명령줄 인자 파서 설정
    parser = argparse.ArgumentParser(description='URL content extractor with parallel processing')
    parser.add_argument('csv_file_path', nargs='?', 
                       help='Path to CSV file containing URLs to process')
    parser.add_argument('--url_column', '-c', default='decoded_url',
                       help='Name of the column containing URLs (default: decoded_url)')
    parser.add_argument('--output_dir', '-o', 
                       help='Output directory for results (default: same as input file)')
    parser.add_argument('--batch_size', '-b', type=int, default=10,
                       help='Batch size for saving interim results (default: 10)')
    parser.add_argument('--workers', '-w', type=int, default=1,
                       help='Number of worker threads for parallel processing (default: 1)')
    
    args = parser.parse_args()
    
    # 기본 파일 경로 (명령줄에서 제공되지 않은 경우)
    if args.csv_file_path is None:
        csv_file_path = r"C:\Users\yhsur\Downloads\특징주\sample_data\Combined_sample_data_500_decoded_2025-05-20_224740.csv"
        print(f"⚠️  기본 파일 경로 사용: {csv_file_path}")
    else:
        csv_file_path = args.csv_file_path
    
    # 설정 정보 출력
    print(f"  입력 파일: {csv_file_path}")
    print(f"  URL 컬럼명: {args.url_column}")
    print(f"  출력 디렉토리: {args.output_dir or '입력 파일과 동일'}")
    print(f"  배치 크기: {args.batch_size}")
    print(f"  작업자 수: {args.workers}")
    
    # 함수 실행
    results, saved_file = process_urls_from_csv(
        csv_file_path, 
        url_column=args.url_column,
        output_dir=args.output_dir,
        batch_size=args.batch_size,
        workers=args.workers
    )

    if results:
        print(f"\n  저장된 파일: {saved_file}")

        print("\n  처리 결과 샘플:")
        for i, result in enumerate(results[:3]):
            print(f"\n[{i+1}] {result['url'][:50]}...")
            print(f"    상태: {result['status']}")
            print(f"    제목: {result['title']}")
            print(f"    처리시간: {result['processing_time']:.2f}초")
            if result["status"] == "failed":
                print(f"    오류: {result['error_message']}")
        
        print(f"\n✅ 처리 완료! 총 {len(results)}개 URL 처리됨")
    else:
        print(f"\n❌ 처리 실패. 위의 오류 메시지를 확인하세요.")


if __name__ == "__main__":
    main()

python script.py input.csv --workers 5 --batch_size 20 --url_column "link" --output_dir "./results"

input.csv: 처리할 CSV 파일 경로 (필수 파라미터)
--workers 5: 병렬 처리 스레드 수 (기본값: 1, 추천: CPU 코어 수의 1-2배)
--batch_size 20: 중간 저장 단위 (기본값: 10, 대용량 처리 시 50-100 권장)
--url_column "link": URL이 들어있는 컬럼명 (기본값: "decoded_url")
--output_dir "./results": 결과 파일 저장 디렉토리 (기본값: 입력 파일과 동일한 폴더)

️ 실행결과

성능 평가 및 결과 해석

병렬 처리를 적용한 결과, 개당 평균 처리 속도는 0.61 → 0.79초로 증가하였으나, 병렬 처리 효과로 인해 전체 처리 시간은 60% 감소하였다.

성능 지표	순차 처리 (Sequential)	병렬 처리 (Parallel)	비교 결과
총 처리 시간 (500개 기사 수집)	5분 05초	1분 59초	⏱ 60% 감소
평균 개별 처리 시간	0.61초	0.79초	30% 감소
전체 처리 효율성	낮음 (순차 대기)	높음 (동시 처리)	2.5배 향상
성공률	81.4%	81.2%	동등 수준
사용된 작업자 수	1개	5개	병렬 처리 활용

스레드 수를 5개로 늘렸지만 처리 시간이 정확히 1/5로 줄지는 않았는데, 그 이유는 다음과 같은 요인들 때문일 것으로 추정:

네트워크 지연: 전체 작업 시간 중 대부분이 요청/응답 대기일 수 있음
서버 반응 속도 제한: 일부 서버는 동시 요청을 제한하거나 봇으로 인식해 지연 응답할 가능성
스레드 오버헤드: 스레드 관리 및 메모리 할당 등의 부하가 효율을 일부 상쇄했을 수 있음

※ 실제 병목 원인은 작업 대상의 구조와 환경에 따라 달라질 수 있으며, 위 내용은 일반적인 웹 크롤링 병렬 처리에서 자주 관찰되는 패턴임

마무리

웹 크롤링 작업에서 request와 threadpoolexecutor를 활용해 실행 시간을 5분에서 2분으로 단축하는 데 성공했다. 간단한 병렬화 코드만 추가하여 60% 이상의 시간 절약, 그리고 2.5배 처리 속도 향상이라는 결과를 얻었을 수 있었다. 다음 글에는 requests에서 html 수집에 실패한 동적 웹사이트에서 정보를 가져오는 방법을 다룰 예정이다. 주로 자바스크립트를 이용한 동적 웹사이트에서 html을 수집하기 위해서 playwright와 같은 브라우저 자동화를 적용할 예정이다.

Trafilatura - requsets를 이용한 한글깨짐 문제 해결하기

catalystmind — Tue, 3 Jun 2025 22:14:22 +0900

TL;DR

Trafilatura를 이용한 한글 뉴스 기사 본문 자동 수집 시 인코딩 문제가 간헐적으로 발생함
한글 뉴스 기사의 약 80%는 정적인 HTML 페이지로 구성되어 requests로 수집 가능함
requests로 HTML을 받아서 trafilatura로 넘기면 인코딩 문제 회피하면서도 빠른 처리 속도 유지 가능함
Trafilatura + requests 조합 테스트 결과, 인코딩 처리를 위해 0.52초 → 0.61초로 다소 증가하였으나 인코딩 문제를 완전히 해결
이 방식을 통해 한글 뉴스 기사 수집의 안정성과 효율성을 동시에 확보할 수 있음

한국어 뉴스를 스크랩할 때 한글 문자가 깨지는 현상이 종종 발생한다. 이전 글에서 소개한 Trafilatura가 자동으로 문자를 변환해주지만 완벽하지는 않다. 이번 글에서는 이 문제를 해결하기 위해, requests로 HTML을 받아와 Trafilatura로 넘겨주는 방식을 다룬다. 특히, requests가 자체적으로 인코딩 문제를 완벽히 처리하지 못하므로, 이를 보완하는 별도의 문자 변환 함수도 소개한다.

웹 크롤링 시 한글 처리 흐름

HTTP 요청 및 응답 수신

requests로 서버에 요청을 보내고 response.content로 HTML 데이터를 받음

서버 문자 정보의 한계

서버 보낸 문자 방식을 잘못 변환하는 경우가 있음
예: 실제는 EUC-KR인데 UTF-8로 변환

텍스트 변환 방법

HTML 데이터를 올바른 텍스트로 변환하는 것이 핵심:

response.encoding → requests의 자동 해석, 부정확할 수 있음
'euc-kr','utf-8','cp949'등을 명시 → 지정한 방식으로 변환
guess_best_decode() → 한글 비율로 최적 방식 추정

정상 텍스트 처리

올바른 변환으로 한글 깨짐 없는 텍스트를 얻음
이후 trafilatura 등으로 본문 추출이 가능

Requests: 빠르고 안정적인 HTML 수집 도구

requests는 가장 널리 사용되는 Python의 HTTP 라이브러리로, 웹 서버로부터 HTML을 빠르게 받아올 수 있다. 특히 정적인 HTML로 구성된 뉴스 기사를 수집할 때 매우 효율적이다.

Requests 사용 시 주요 장점

1. 인코딩을 직접 지정해서 문자가 깨지는 문제를 막을 수 있음
아래의 예시를 보면 서버는 분명히 charset=EUC-KR로 보냈는데, 제목은 깨져서 나왔다. 이는 html을 받은 후 서버가 보낸 charset을 제대로 변환하지 못했기 때문이다. trafilatura를 사용하면 이부분을 바로 잡아줄 수 없지만, requests를 사용하면 이 부분을 제대로 잡아 줄 기회가 있다.

        <title> ̱        پ  µ   ѱ     "  ġ  ׸  ָ   ⷷ"    ̵           -  Ӵ       </title>
        <meta http-equiv="content-type" content="text/html; charset=EUC-KR">

2. 가볍고 빠른 요청 처리
브라우저를 사용하지 않고 순수 HTML 요청만 처리하기 때문에 속도가 빠르고 리소스 사용량도 적다.이전 글에서도 언급했듯, 우리가 수집하는 한글 뉴스의 약 80%는 정적 페이지로 만들어져 있다. 따라서, requests와 문자열 보정 함수를 거치더라도, 전체적인 수집 속도는 여전히 빠르게 유지될 수 있다.

Requests + Trafilatura의 기본 사용법

다음과 같은 간단한 코드로 쉽게 두 기능을 결합할 수 있다. 아래는 requests로 html을 받아와서 trafilatura에 넘겨주는 기본 코드이다. 여기서는 requests가 인코딩을 추정하는 기본 기능인 apparent_encoding을 적용하였다.

import requests
import trafilatura
from trafilatura.metadata import extract_metadata

# 대상 URL 설정
url = "https://news.mt.co.kr/mtview.php?no=2025050210033043266&VMK"

# HTML 다운로드 (requests 사용)
response = requests.get(url, timeout=10)
response.encoding = response.apparent_encoding  # 인코딩 자동 감지
downloaded = response.text

# 메타데이터 및 본문 텍스트 추출
metadata = extract_metadata(downloaded)
text = trafilatura.extract(downloaded, output_format='txt', include_comments=False, favor_precision=True)

# 결과 출력
print(f"  제목: {metadata.title}")
print(f"  날짜: {metadata.date}")
print(f"  본문:\n{text}")

하지만, apparent_encoding으로는 여전히 제대로 인식이 되지 않는 웹사이트가 존재하여, 아래와 같이 별도의 문자열 인식 함수를 추가하였다. 이 함수를 간단히 설명하면, response.encoding → response.apparent_encoding → 'utf-8' → 'euc-kr' → 'cp949'을 순차적으로 테스트 해보면서 한글이 많이 나오는 인코딩 방식을 선정하는 함수다.

def guess_best_decode(data: bytes, encodings: List[str]) -> str:
    """Pick the decoding that yields the most Hangul characters."""
    best_text: Optional[str] = None
    best_score = -1
    for enc in encodings:
        if not enc:
            continue
        try:
            text = data.decode(enc, errors="replace")
        except LookupError:
            continue
        # Score by Hangul character count
        score = sum(0xAC00 <= ord(ch) <= 0xD7A3 for ch in text)
        if score > best_score:
            best_text, best_score = text, score
        # Early exit if score is very high (heuristic)
        if score > 10:
            break
    if best_text is None:
        best_text = data.decode("utf-8", errors="replace")
    return best_text
    
def fetch_html_with_requests(url: str, timeout: int = 10) -> dict:
    """
    requests로 HTML만 다운로드하는 함수 (본문 추출은 별도로 수행)
    guess_best_decode를 활용한 강력한 인코딩 자동 보정
    """
    result = {
        'url': url,
        'html': '',
        'success': False,
        'error': None,
        'method_used': 'requests_only'
    }

    try:
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36'
        }
        response = requests.get(url, headers=headers, timeout=timeout)
        response.raise_for_status()
        # ✅ guess_best_decode를 통해 인코딩 복원
        candidates = [
        response.encoding,           # 서버가 응답 헤더에 명시한 인코딩
        response.apparent_encoding,  # requests가 추정한 인코딩
        'utf-8',                     # 가장 일반적인 기본값
        'euc-kr',                    # 한국 뉴스에서 흔히 사용됨
        'cp949'                      # euc-kr의 superset, Windows 환경에서 자주 사용
        ]

        result['html'] = guess_best_decode(response.content, candidates)
        result['success'] = True

    except Exception as e:
        result['error'] = str(e)

    return result

Trafilatura - Requests 조합의 성능을 평가해 보자

성능 평가를 위해, 앞의 글에서 사용한 500개 URL이 담긴 파일을 그대로 사용했다. 성능 평가를 위한 최종 코드를 아래와 같이 작성하였다.

URL Batch Processor (Trafilatura + requests) 펼치기


import pandas as pd
import trafilatura
from trafilatura.metadata import extract_metadata
import requests
import time
from datetime import datetime
import csv
from typing import List, Optional


def guess_best_decode(data: bytes, encodings: List[str]) -> str:
    """Pick the decoding that yields the most Hangul characters."""
    best_text: Optional[str] = None
    best_score = -1
    for enc in encodings:
        if not enc:
            continue
        try:
            text = data.decode(enc, errors="replace")
        except LookupError:
            continue
        # Score by Hangul character count
        score = sum(0xAC00 <= ord(ch) <= 0xD7A3 for ch in text)
        if score > best_score:
            best_text, best_score = text, score
        # Early exit if score is very high (heuristic)
        if score > 10:
            break
    if best_text is None:
        best_text = data.decode("utf-8", errors="replace")
    return best_text

def fetch_html_with_requests(url: str, timeout: int = 10) -> dict:
    """
    requests로 HTML만 다운로드하는 함수 (본문 추출은 별도로 수행)
    guess_best_decode를 활용한 강력한 인코딩 자동 보정
    """
    result = {
        'url': url,
        'html': '',
        'success': False,
        'error': None,
        'method_used': 'requests_only'
    }

    try:
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36'
        }
        response = requests.get(url, headers=headers, timeout=timeout)
        response.raise_for_status()

        # ✅ guess_best_decode를 통해 인코딩 복원
        candidates = [
            response.encoding,
            response.apparent_encoding,
            'utf-8',
            'euc-kr',
            'cp949'
        ]
        result['html'] = guess_best_decode(response.content, candidates)
        result['success'] = True

    except Exception as e:
        result['error'] = str(e)

    return result

def process_single_url(url, index, total_urls):
    """단일 URL 처리 함수"""
    start_time = time.time()
    result = {
        "index": index,
        "url": url,
        "status": "failed",
        "title": None,
        "date": None,
        "content": None,
        "processing_time": 0,
        "error_message": None,
    }
    
    try:
        print(f"Processing URL {index + 1}/{total_urls}: {url[:60]}...")
        
        # HTML 다운로드
        html_result = fetch_html_with_requests(url)
        
        if html_result['success']:
            html_content = html_result['html']
            
            # trafilatura로 메타데이터 추출
            metadata = trafilatura.extract_metadata(html_content)
            
            # trafilatura로 본문 추출
            text = trafilatura.extract(
                html_content,
                output_format="txt",
                include_comments=False,
                favor_precision=True,
            )
            
            if text and len(text.strip()) > 0:
                result.update({
                    "status": "success",
                    "title": metadata.title if metadata and metadata.title else "No title",
                    "date": str(metadata.date) if metadata and metadata.date else "No date",
                    "content": text[:200] + "..." if len(text) > 200 else text,
                })
            else:
                result["error_message"] = "Empty content extracted"
        else:
            result["error_message"] = f"Failed to download page: {html_result['error']}"
            
    except Exception as e:
        result["error_message"] = str(e)
    
    # 처리 시간 계산
    processing_time = time.time() - start_time
    result["processing_time"] = processing_time
    
    return result


def save_results_to_csv(results, output_file=None):
    """결과를 CSV 파일로 저장"""

    # 파일명이 지정되지 않으면 현재 시간을 포함한 파일명 생성
    if output_file is None:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        output_file = f"url_processing_results_{timestamp}.csv"

    try:
        with open(output_file, "w", newline="", encoding="utf-8") as csvfile:
            fieldnames = [
                "index",
                "url",
                "status",
                "title",
                "date",
                "content",
                "processing_time",
                "error_message",
            ]
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

            writer.writeheader()
            for result in results:
                writer.writerow(result)

        print(f"✅ 결과가 '{output_file}' 파일에 저장되었습니다.")
        return output_file  # 실제 저장된 파일명 반환

    except Exception as e:
        print(f"❌ 결과 저장 실패: {e}")
        return None


def print_summary(results, total_time, skipped_count=0):
    """처리 결과 요약 출력"""
    total_urls = len(results)
    successful_count = sum(1 for r in results if r["status"] == "success")
    failed_count = total_urls - successful_count
    processing_times = [r["processing_time"] for r in results]

    print("\n" + "=" * 7 + " SUMMARY " + "=" * 7)
    print(f"Total URLs processed: {total_urls}")
    print("Workers used: 1")  # 단일 스레드 처리
    print(f"Successfully decoded: {successful_count} ({successful_count/total_urls*100:.1f}%)")
    print(f"Failed to decode: {failed_count} ({failed_count/total_urls*100:.1f}%)")
    print(f"Skipped (Google News URLs): {skipped_count} ({skipped_count/(total_urls + skipped_count)*100:.1f}%)")

    if processing_times:
        avg_time = sum(processing_times) / len(processing_times)

        print("\n" + "-" * 5 + " TIMING INFORMATION " + "-" * 5)
        print(f"Total processing time: {int(total_time//60)}:{total_time%60:05.2f}")
        print(f"Average processing time per URL: {avg_time:.2f} seconds")
        print(f"Fastest URL processing time: {min(processing_times):.2f} seconds")
        print(f"Slowest URL processing time: {max(processing_times):.2f} seconds")

    print("\nProcess completed successfully. Results saved to CSV file.")


def process_urls_from_csv(csv_file_path, url_column="decoded_url"):
    """CSV 파일에서 URL들을 읽어서 순차 처리"""

    print("=" * 50)
    print("  URL 배치 처리 시작")
    print("=" * 50)

    # CSV 파일 읽기
    try:
        df = pd.read_csv(csv_file_path)
        print(f"  CSV 파일 컬럼들: {list(df.columns)}")
        print(f"  총 행 수: {len(df)}")

        if url_column not in df.columns:
            raise ValueError(f"Column '{url_column}' not found in CSV file")

        print(f"  '{url_column}' 컬럼의 NULL이 아닌 값 개수: {df[url_column].notna().sum()}")

        all_urls = df[url_column].dropna().tolist()
        print(f"  첫 번째 URL 샘플: {all_urls[0] if all_urls else 'None'}")

        # news.google.com이 포함되지 않은 URL만 필터링
        urls = [url for url in all_urls if "news.google.com" not in str(url)]

        total_urls = len(urls)
        skipped_urls = len(all_urls) - total_urls

        print(f"  전체 URL: {len(all_urls)}개")
        print(f"  처리 대상 URL (decoded URLs): {total_urls}개")
        print(f"  건너뛴 URL (Google News URLs): {skipped_urls}개")

        if urls:
            print(f"  첫 번째 디코딩된 URL 샘플: {urls[0]}")

        print("-" * 30)

    except Exception as e:
        print(f"❌ CSV 파일 읽기 실패: {e}")
        return None

    total_start_time = time.time()
    results = []
    successful_count = 0
    failed_count = 0

    for i, url in enumerate(urls):
        result = process_single_url(url, i, total_urls)
        results.append(result)

        if result["status"] == "success":
            successful_count += 1
        else:
            failed_count += 1

        if (i + 1) % 10 == 0 or (i + 1) == total_urls:
            print(
                f"진행: {i + 1}/{total_urls} "
                f"({(i + 1)/total_urls*100:.1f}%) "
                f"성공: {successful_count}, 실패: {failed_count}"
            )

    total_processing_time = time.time() - total_start_time
    print_summary(results, total_processing_time, skipped_urls)

    saved_file = save_results_to_csv(results)
    return results, saved_file


def main():
    csv_file_path = r"C:\Users\yhsur\Downloads\특징주\sample_data\Combined_sample_data_500_decoded_2025-05-20_224740.csv"
    results, saved_file = process_urls_from_csv(csv_file_path, url_column="decoded_url")

    if results:
        print(f"\n  저장된 파일: {saved_file}")

        print("\n  처리 결과 샘플:")
        for i, result in enumerate(results[:3]):
            print(f"\n[{i+1}] {result['url'][:50]}...")
            print(f"    상태: {result['status']}")
            print(f"    제목: {result['title']}")
            print(f"    처리시간: {result['processing_time']:.2f}초")
            if result["status"] == "failed":
                print(f"    오류: {result['error_message']}")


if __name__ == "__main__":
    main()

️ 실행결과

진행: 500/500 (100.0%) 성공: 407, 실패: 93

======= SUMMARY =======
Total URLs processed: 500
Workers used: 1
Successfully decoded: 407 (81.4%)
Failed to decode: 93 (18.6%)
Skipped (Google News URLs): 0 (0.0%)

----- TIMING INFORMATION -----
Total processing time: 5:05.95
Average processing time per URL: 0.61 seconds
Fastest URL processing time: 0.06 seconds
Slowest URL processing time: 3.96 seconds

Process completed successfully. Results saved to CSV file.
✅ 결과가 'url_processing_results_20250531_004542.csv' 파일에 저장되었습니다.

  저장된 파일: url_processing_results_20250531_004542.csv

성능 평가 및 결과

항목	trafilatura	requests + trafilatura
문자 인코딩 처리	제한적 (간헐적 오류)	완전 제어 가능
처리 속도	빠름 (예: 0.52초)	약간 느림 (예: 0.61초)
설정 유연성	낮음	높음
디버깅/오류 추적	어려움	용이

마무리

이번 전략은 뉴스 수집의 일관성과 품질을 크게 향상시킨다.일관성이 중요한 이유는, 추후 문제가 발견되었을 때 수정과 재수집에 소요되는 비용을 줄일 수 있기 때문이다. 수집 대상 URL의 80% 이상이 정적 HTML이라면, requests와 trafilatura 조합이 지금까지 시도한 방법 중 가장 실용적이다.

다음 글에서는 이 전략을 더욱 발전시켜, 병렬 처리를 적용하여 처리 속도를 더욱 단축하는 방법을 시도하겠다.

Trafilatura를 이용한 뉴스 스크래핑

catalystmind — Fri, 30 May 2025 21:03:05 +0900

TL;DR

Trafilatura: 웹페이지에서 핵심 본문만 자동 추출하는 파이썬 라이브러리

✅ 주요 장점

웹사이트에서 광고 및 불필요한 내용 제거하고 본문만 추출, 웹사이트마다 본문의 구조가 다른 점을 해결

성능 평가 결과

500개 URL 테스트에서 성공률 81.4%, 평균 처리시간 0.52초 달성

⚠️ 주요 한계

자바스크립트 렌더링, 한글 인코딩 오류 시 본문 추출 실패

Trafilatura로 시작하는 뉴스 자동화의 전환점

뉴스 데이터는 투자, 여론 분석, 정보 탐색 등 다양한 목적으로 활용되는 핵심 정보다. 특히, 시간이 부족한 직장인 투자자에게 빠르게 뉴스와 시장의 흐름을 판단하기 위해서는 자동화가 필요한데, 자동으로 기사를 수집하고 정제하는 과정에는 많은 어려움이 있다.

⚠️ 기존 방식의 한계: Power Automate + GPT

이전에 Microsoft Power Automate를 활용해 뉴스 기사를 수집하고, GPT를 이용해 본문을 정제하는 자동화 워크플로우를 구성했다. 기사의 웹싸이트에서 텍스트 추출까지는 성공했지만, 곧 다음과 같은 문제에 부딪혔다.

1. 정제 비용 문제: 웹사이트에서 본문뿐만 아니라 광고, 댓글, 관련 기사 링크 등 불필요한 정보까지 함께 수집되다 보니, GPT 후처리 시 토큰 낭비가 심각했다. 불필요한 텍스트는 곧 비용으로 연결된다.

2. 유지보수 문제: 뉴스 사이트마다 HTML 구조가 달라 본문 위치를 정확히 찾는 작업을 반복해야 했고, 사이트가 조금만 바뀌어도 본문 추출 방법이 무력화된다.

Trafilatura: 웹에서 핵심 본문만 추출하는 파이썬 도구

Trafilatura는 웹페이지에서 핵심 콘텐츠만 뽑아주는 파이썬 기반 라이브러리로, 뉴스, 블로그에서 본문을 추출하는데 특화되어 있어 위에서 언급한 문제점을 해결할 수 있는 가장 현실적인 방안이다.

Trafilatura의 주요 장점

1. 불필요한 요소 자동 제거 광고, 네비게이션 바, 댓글, 추천 기사 등 콘텐츠 이외 요소를 필터링해서 본문만 남겨준다. 이렇게 정제된 데이터는 GPT 같은 언어 모델에 넘기기에 최적화되어 있다.

2. 다양한 사이트 구조 대응 뉴스, 블로그 등 다양한 HTML 구조에 자동으로 적응한다. 별도 규칙 정의 없이도 대부분의 웹사이트에서 본문을 추출할 수 있어 유지보수 부담이 크게 줄어든다.

Trafilatura는 뉴스 데이터 정제 비용을 줄이고 유지보수를 간소화하는 핵심 도구다.

Trafilatura의 기본 사용법

다음과 같은 간단한 코드로 쉽게 시작할 수 있다.

import trafilatura
from trafilatura.metadata import extract_metadata

# 대상 URL 설정
url = "https://www.yna.co.kr/view/AKR20250511050400001?section=election2025/news&site=topnews01"

# URL에서 HTML 다운로드
downloaded = trafilatura.fetch_url(url)

# 메타데이터 및 본문 텍스트 추출
metadata = extract_metadata(downloaded)
text = trafilatura.extract(downloaded, output_format='txt', include_comments=False, favor_precision=True)

# 결과 출력
print(f"  제목: {metadata.title}")
print(f"  날짜: {metadata.date}")
print(f"  본문:\n{text}")

  제목: 21대 대선에 7명 후보 등록…이재명 1번·김문수 2번·이준석 4번 | 연합뉴스
  날짜: 2025-05-11
  본문:
제21대 대통령 선거에 총 7명의 후보가 등록한 것으로 11일 집계됐다.
이준석 후보, 구주와 후보, 송진호 후보는 군 복무를 마쳤다고 신고했다.
후보자 기호는 1번 더불어민주당 이재명, 2번 국민의힘 김문수, 4번 개혁신당 이준석, 5번 민주노동당 권영국, 6번 자유통일당 구주와, 7번 무소속 황교안, 8번 무소속 송진호 후보로 결정됐다.
전체 내용을 이...

Trafilatura의 성능을 평가해 보자

Trafilatura의 성능을 평가하기 위해, 500개의 다양한 기사 원문 URL이 담긴 파일에서 URL을 불러와 처리 속도와 성공률을 측정하는 코드를 추가했다.

URL Batch Processor (Trafilatura) 펼치기


import pandas as pd
import trafilatura
from trafilatura.metadata import extract_metadata
import time
from datetime import datetime
import csv


def process_single_url(url, index, total_urls):
    """단일 URL 처리 함수"""
    start_time = time.time()
    result = {
        "index": index,
        "url": url,
        "status": "failed",
        "title": None,
        "date": None,
        "content": None,
        "processing_time": 0,
        "error_message": None,
    }

    try:
        print(f"Processing URL {index + 1}/{total_urls}: {url[:60]}...")

        # URL 다운로드
        downloaded = trafilatura.fetch_url(url)

        if downloaded:
            # 메타데이터 추출
            metadata = extract_metadata(downloaded)

            # 본문 추출
            text = trafilatura.extract(
                downloaded,
                output_format="txt",
                include_comments=False,
                favor_precision=True,
            )

            if text and len(text.strip()) > 0:
                result.update(
                    {
                        "status": "success",
                        "title": metadata.title if metadata else "No title",
                        "date": str(metadata.date) if metadata and metadata.date else "No date",
                        "content": text[:200] + "..." if len(text) > 200 else text,
                    }
                )
            else:
                result["error_message"] = "Empty content extracted"
        else:
            result["error_message"] = "Failed to download page"

    except Exception as e:
        result["error_message"] = str(e)

    # 처리 시간 계산
    processing_time = time.time() - start_time
    result["processing_time"] = processing_time

    return result


def save_results_to_csv(results, output_file=None):
    """결과를 CSV 파일로 저장"""

    # 파일명이 지정되지 않으면 현재 시간을 포함한 파일명 생성
    if output_file is None:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        output_file = f"url_processing_results_{timestamp}.csv"

    try:
        with open(output_file, "w", newline="", encoding="utf-8") as csvfile:
            fieldnames = [
                "index",
                "url",
                "status",
                "title",
                "date",
                "content",
                "processing_time",
                "error_message",
            ]
            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)

            writer.writeheader()
            for result in results:
                writer.writerow(result)

        print(f"✅ 결과가 '{output_file}' 파일에 저장되었습니다.")
        return output_file  # 실제 저장된 파일명 반환

    except Exception as e:
        print(f"❌ 결과 저장 실패: {e}")
        return None


def print_summary(results, total_time, skipped_count=0):
    """처리 결과 요약 출력"""
    total_urls = len(results)
    successful_count = sum(1 for r in results if r["status"] == "success")
    failed_count = total_urls - successful_count
    processing_times = [r["processing_time"] for r in results]

    print("\n" + "=" * 7 + " SUMMARY " + "=" * 7)
    print(f"Total URLs processed: {total_urls}")
    print("Workers used: 1")  # 단일 스레드 처리
    print(f"Successfully decoded: {successful_count} ({successful_count/total_urls*100:.1f}%)")
    print(f"Failed to decode: {failed_count} ({failed_count/total_urls*100:.1f}%)")
    print(f"Skipped (Google News URLs): {skipped_count} ({skipped_count/(total_urls + skipped_count)*100:.1f}%)")

    if processing_times:
        avg_time = sum(processing_times) / len(processing_times)

        print("\n" + "-" * 5 + " TIMING INFORMATION " + "-" * 5)
        print(f"Total processing time: {int(total_time//60)}:{total_time%60:05.2f}")
        print(f"Average processing time per URL: {avg_time:.2f} seconds")
        print(f"Fastest URL processing time: {min(processing_times):.2f} seconds")
        print(f"Slowest URL processing time: {max(processing_times):.2f} seconds")

    print("\nProcess completed successfully. Results saved to CSV file.")


def process_urls_from_csv(csv_file_path, url_column="decoded_url"):
    """CSV 파일에서 URL들을 읽어서 순차 처리"""

    print("=" * 50)
    print("  URL 배치 처리 시작")
    print("=" * 50)

    # CSV 파일 읽기
    try:
        df = pd.read_csv(csv_file_path)
        print(f"  CSV 파일 컬럼들: {list(df.columns)}")
        print(f"  총 행 수: {len(df)}")

        if url_column not in df.columns:
            raise ValueError(f"Column '{url_column}' not found in CSV file")

        print(f"  '{url_column}' 컬럼의 NULL이 아닌 값 개수: {df[url_column].notna().sum()}")

        all_urls = df[url_column].dropna().tolist()
        print(f"  첫 번째 URL 샘플: {all_urls[0] if all_urls else 'None'}")

        # news.google.com이 포함되지 않은 URL만 필터링
        urls = [url for url in all_urls if "news.google.com" not in str(url)]

        total_urls = len(urls)
        skipped_urls = len(all_urls) - total_urls

        print(f"  전체 URL: {len(all_urls)}개")
        print(f"  처리 대상 URL (decoded URLs): {total_urls}개")
        print(f"  건너뛴 URL (Google News URLs): {skipped_urls}개")

        if urls:
            print(f"  첫 번째 디코딩된 URL 샘플: {urls[0]}")

        print("-" * 30)

    except Exception as e:
        print(f"❌ CSV 파일 읽기 실패: {e}")
        return None

    total_start_time = time.time()
    results = []
    successful_count = 0
    failed_count = 0

    for i, url in enumerate(urls):
        result = process_single_url(url, i, total_urls)
        results.append(result)

        if result["status"] == "success":
            successful_count += 1
        else:
            failed_count += 1

        if (i + 1) % 10 == 0 or (i + 1) == total_urls:
            print(
                f"진행: {i + 1}/{total_urls} "
                f"({(i + 1)/total_urls*100:.1f}%) "
                f"성공: {successful_count}, 실패: {failed_count}"
            )

    total_processing_time = time.time() - total_start_time
    print_summary(results, total_processing_time, skipped_urls)

    saved_file = save_results_to_csv(results)
    return results, saved_file


def main():
    csv_file_path = r"C:\Users\yhsur\Downloads\특징주\sample_data\Combined_sample_data_500_decoded_2025-05-20_224740.csv"
    results, saved_file = process_urls_from_csv(csv_file_path, url_column="decoded_url")

    if results:
        print(f"\n  저장된 파일: {saved_file}")

        print("\n  처리 결과 샘플:")
        for i, result in enumerate(results[:3]):
            print(f"\n[{i+1}] {result['url'][:50]}...")
            print(f"    상태: {result['status']}")
            print(f"    제목: {result['title']}")
            print(f"    처리시간: {result['processing_time']:.2f}초")
            if result["status"] == "failed":
                print(f"    오류: {result['error_message']}")


if __name__ == "__main__":
    main()

️ 실행결과

진행: 500/500 (100.0%) 성공: 407, 실패: 93

======= SUMMARY =======
Total URLs processed: 500
Workers used: 1
Successfully decoded: 407 (81.4%)
Failed to decode: 93 (18.6%)
Total errors: 93 (18.6%)
Skipped (Google News URLs): 0 (0.0%)

----- TIMING INFORMATION -----
Total processing time: 4:20.64
Average processing time per URL: 0.52 seconds
Average processing time per decoded URL: 0.52 seconds
Fastest URL processing time: 0.05 seconds
Slowest URL processing time: 5.26 seconds

Process completed successfully. Results saved to CSV file.
✅ 결과가 'url_processing_results_20250525_131353.csv' 파일에 저장되었습니다.

  저장된 파일: url_processing_results_20250525_131353.csv

성능 평가 및 결과

Claude를 사용해서, 평가 결과를 분석 및 시각화를 진행하였다.

분석 요약

요약 정보

총 레코드 수

500

성공률

81.4%

평균 처리 시간

0.521초

중앙값 처리 시간

0.314초

처리 시간 분포

120 80 40 0

0.0-0.5

0.5-1.0

1.0-1.5

1.5-2.0

2.0-2.5

2.5초+

처리 시간 (초)

500

총 처리 건수

실패 건수

18.6%

실패율

2개

주요 문제 도메인

주요 문제: 전체 실패 96.8%(90건) - biz.chosun.com, www.msn.com 발생

전체 처리 현황

성공

407건

81.4%

실패

93건

18.6%

알수없음

0건

주요 문제 도메인 상세 분석

1. biz.chosun.com

62건

총 시도

62건

실패

성공률

66.7%

전체 실패 중 비율

주요 오류:

Empty content extracted - 모든 시도 콘텐츠 추출 실패

원인: JavaScript 기반 동적 로딩, 접근 제한(Cloudflare, bot detection) 추정

2. www.msn.com

28건

총 시도

28건

실패

성공률

30.1%

전체 실패 중 비율

주요 오류:

Empty content extracted - 모든 시도 콘텐츠 추출 실패

Failed to download page - 일부 요청 페이지 다운로드 실패

원인: Microsoft 서비스 강력한 bot detection, 지역별 접근 제한

기타 실패: 나머지 3건 - 네트워크 일시적 장애, 페이지 구조 변경 추정

오류 패턴 분석

오류 유형별 분포

Empty content extracted

87건 (93.5%)

콘텐츠 추출 실패 - JavaScript 렌더링 필요, 접근 차단

Failed to download page

6건 (6.5%)

페이지 다운로드 실패 - 네트워크 오류, 서버 응답 없음

인코딩 및 문자 처리 문제

발견된 문제: 일부 성공 데이터 특수문자, 인코딩 문제 발견

주요 인코딩 문제:

한글 깨짐 현상 (UTF-8 vs EUC-KR 인코딩 충돌)
특수문자( ) 표시 - 원본 사이트의 인코딩 문제
HTML 엔티티 미변환 (&, <, > 등)
줄바꿈 문자 처리 문제 (\r\n, \n 혼재)

권장 해결책: chardet 라이브러리 자동 인코딩 감지, HTML 파싱 전 인코딩 정규화, 후처리 특수문자 정리 필요

마무리

Trafilatura는 정적 HTML 기사 추출에 특화된 도구다. Claude로 분석한 결과, 500개 기사 URL 테스트에서 평균 처리 속도는 0.521초, 성공률은 81.4%로 빠른 성능을 보여주었고, 추출에 실패한 웹사이트는 대부분 자바스크립트 기반 웹사이트 또는 한글 인코딩 문제가 있는 페이지로 확인되었다. Trafilatura는 정적 구조에 최적화되어 있으며, 동적 콘텐츠 처리에는 한계가 있다.다음 글에서는 한글 인코딩 문제가 있는 페이지와 자바스크립트 기반 웹사이트에 대한 대응 전략을 다루고자 한다.

Googlenewsdecoder - 병렬처리로 시간 단축하기

catalystmind — Sat, 24 May 2025 23:35:43 +0900

TL;DR

GoogleNewsDecoder는 I/O 바운드 작업으로 병렬 처리에 적합한 특성을 가짐
Python의 concurrent.futures 라이브러리를 활용해 ThreadPoolExecutor 기반의 병렬 처리 시스템 구현
submit()과 as_completed() 메서드를 조합한 비동기 처리를 통해 전체 작업 시간을 대폭 단축
기존 순차 처리 방식 대비 다중 스레드 병렬 처리로 성능 향상 달성

googlenewsdecoder - 병렬 처리의 필요성

googlenewsdecoder를 활용하여 500개의 기사를 순차적으로 처리할 경우, 기사 하나당 평균 처리 시간은 3초로 전체 처리시간은 26분 57초가 소요되었다. 원문 URL을 알아내는데만 이렇게 긴 시간을 소비하는 것은 매우 비효율적이며 다음 작업에 필요한 시간을 감안하면 이 단계에서 소요되는 시간을 더 단축할 필요가 있다.

googlenewsdecoder는 다음과 같은 병렬 처리에 적합한 특징을 가지고 있다.

I/O 바운드 작업: googlenewsdecoder의 주요 작업은 네트워크 요청으로 이루어짐.
독립적인 작업: 각 URL 처리 작업은 독립적으로, 이전 처리작업 결과를 다음 작업에 영향을 미치지 않음.

concurrent.futures - 병렬작업을 위한 python 패키지

Python의 concurrent.futures는 멀티스레드 또는 멀티프로세스를 간편하게 구현할 수 있는 표준 라이브러리로, 멀티스레드의 경우 웹 크롤링이나 파일 I/O와 같은 I/O 바운드 작업의 병렬 처리에 매우 적합하다. 따라서, 이번 글에는 멀티스레드를 이용한 병렬처리를 다루고자 한다.

비교 항목	스레드 (Thread)	프로세스 (Process)
사용 자원	메모리 공유 같은 프로세스 내에서 메모리 영역을 공유	별도 메모리 각 프로세스마다 독립적인 메모리 공간
적합한 작업	I/O-bound 웹 요청, 파일 입출력, 데이터베이스 조회 등	CPU-bound 수치 계산, 이미지 처리, 데이터 분석 등
대표 패키지	threading ThreadPoolExecutor	multiprocessing ProcessPoolExecutor
장점	• 가볍고 생성 속도가 빠름 • 메모리 공유로 데이터 전달 효율적 • 컨텍스트 스위칭 비용이 낮음	• GIL 제약 없이 진정한 병렬 처리 • CPU 집약적 작업에 최적화 • 한 프로세스 오류가 다른 프로세스에 영향 없음
단점	• GIL로 인한 CPU-bound 작업 제약 • 공유 자원 접근 시 동기화 문제	• 프로세스 생성/종료 오버헤드 큼 • IPC 비용과 메모리 사용량 증가 • 데이터 공유가 복잡함

사용 예시

googlenewsdecoder + ThreadPoolExecutor를 이용한 URL 병렬 처리의 기본 예시

URL을 병렬로 요청하는 실행 흐름:

• ThreadPoolExecutor: max_workers만큼 작업을 동시 수행
• executor.submit() + as_completed()로 완료된 작업부터 즉시 결과 처리
• submit(): 각 작업을 비동기적으로 실행되도록 등록하는 함수. 반환값은 Future 객체
• as_completed(): 등록된 작업들 중 먼저 완료된 작업의 결과를 순서대로 가져오는 반복자

import concurrent.futures
from googlenewsdecoder import gnewsdecoder

# 구글 뉴스에서 수집한 URL 리스트
encoded_urls = [
   "https://news.google.com/rss/articles/CBMiYWh0dHBzOi8v...",
   "https://news.google.com/rss/articles/CBMiZGh0dHBzOi8v...",
   "https://news.google.com/rss/articles/CBMiY2h0dHBzOi8v...",
]

# 5개 스레드로 병렬 처리
with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
   # 각 URL을 병렬로 처리하도록 작업 제출
   futures = []
   for url in encoded_urls:
       future = executor.submit(gnewsdecoder, url)
       futures.append(future)
   
   # 완료된 순서대로 결과 출력
   for future in concurrent.futures.as_completed(futures):
       result = future.result()
       print(result)

googlenewsdecoder와 concurrent.futures의 통합 하기

googlenewsdecoder는 URL 요청으로 이루어진 I/O 바운드 작업이므로 멀티스레드를 이용한 병렬화 효과가 뛰어나다. 병렬처리를 반영한 최종 코드는 다음과 같다. 전체 코드를 복사해서 아래와 같이 사용하면 된다:

python script_name.py urls.csv --output_dir ./results --interval 2 --batch_size 20 --workers 5

input_file_path URL이 포함된 파일 경로 (CSV 또는 텍스트 파일)
--output_dir, -o: 결과 저장 디렉토리 (기본값: 입력 파일과 동일 위치)
--interval, -i: URL 처리 사이의 대기 시간(초) (기본값: 1)
--batch_size, -b: 중간 결과 저장 단위(URL 개수) (기본값: 10)
--workers, -w: 병렬 처리를 위한 작업자 수 (기본값: 1, 병렬 처리 없음)

전체 파이썬 스크립트는 다음과 같다.

(펼치기 버튼을 누르면 복사하기 버튼이 나타남)

from googlenewsdecoder import gnewsdecoder
import pandas as pd
import os
import time
import argparse
import concurrent.futures
from datetime import datetime, timedelta

def process_urls_from_file(input_file_path, output_dir=None, interval_time=1, batch_size=10, workers=1):
    """
    파일에서 URL을 읽고 처리하는 함수
    
    Args:
        input_file_path: URL이 포함된 파일 경로
        output_dir: 결과 저장 디렉토리 (기본값: 입력 파일과 동일)
        interval_time: URL 처리 사이의 대기 시간 (초)
        batch_size: 중간 결과 저장 단위 (URL 개수)
        workers: 병렬 처리를 위한 작업자 수 (기본값: 1, 병렬 처리 없음)
        
    Returns:
        처리 결과가 포함된 DataFrame 또는 오류 시 None
    """
    # Read URLs from file
    try:
        # 파일 확장자 확인
        file_ext = os.path.splitext(input_file_path)[1].lower()
        
        if file_ext == '.csv':
            # CSV 파일인 경우 pandas로 읽기
            try:
                df = pd.read_csv(input_file_path, encoding='utf-8-sig')
                
                # 'link' 컬럼이 있는지 확인
                if 'link' in df.columns:
                    urls = df['link'].dropna().tolist()
                    print(f"Found {len(urls)} URLs in 'link' column")
                else:
                    available_columns = ', '.join(df.columns)
                    print(f"Error: 'link' column not found in CSV. Available columns: {available_columns}")
                    return None
            except Exception as e:
                print(f"Error parsing CSV file: {e}")
                return None
        else:
            # 일반 텍스트 파일로 간주하고 한 줄에 하나의 URL로 읽기
            with open(input_file_path, 'r', encoding='utf-8-sig') as file:
                urls = [line.strip() for line in file if line.strip()]
                print(f"Found {len(urls)} URLs in text file")
    except Exception as e:
        print(f"Error reading file: {e}")
        return None

    # 파일 저장 기본 설정
    if output_dir is None:
        output_dir = os.path.dirname(input_file_path) or '.'
    
    timestamp = datetime.now().strftime("%Y-%m-%d_%H%M%S")
    input_filename = os.path.basename(input_file_path).split('.')[0]
    output_filename = f"{input_filename}_decoded_{timestamp}.csv"
    output_path = os.path.join(output_dir, output_filename)
    
    print(f"Results will be saved to: {output_path}")
    
    # Process each URL
    results = []
    total_urls = len(urls)
    
    print(f"Starting to process {total_urls} URLs...")
    print(f"Workers: {workers} (Parallel processing: {'Enabled' if workers > 1 else 'Disabled'})")

    # Record overall process start time
    process_start_time = time.time()
    
    # 병렬 처리 사용 여부에 따라 처리 방식 결정
    if workers > 1:
        # 병렬 처리 사용
        completed = 0
        
        # URL 배치로 나누기 (한 번에 batch_size만큼 병렬 처리)
        for batch_start in range(0, total_urls, batch_size):
            batch_end = min(batch_start + batch_size, total_urls)
            batch_urls = urls[batch_start:batch_end]
            batch_size_actual = len(batch_urls)
            
            print(f"Processing URLs {batch_start+1}-{batch_end} of {total_urls}...")
            
            # 병렬 처리 실행
            with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
                # URL을 병렬로 처리
                future_to_url = {executor.submit(process_url, url, interval_time): url for url in batch_urls}
                
                # 결과 수집
                for future in concurrent.futures.as_completed(future_to_url):
                    result = future.result()
                    results.append(result)
                    completed += 1
                    
                    # 진행 상황 표시 (10개마다 또는 배치 완료 시)
                    if completed % 10 == 0 or completed == total_urls:
                        print(f"Processed {completed}/{total_urls} URLs...")
            
            # 현재 배치의 결과를 CSV 파일로 저장
            current_df = pd.DataFrame(results)
            current_df.to_csv(output_path, index=False, encoding='utf-8')
            print(f"Saved {len(results)} results to: {output_path}")
    else:
        # 직렬 처리 사용 (기존 방식)
        for i, url in enumerate(urls):
            if i % 10 == 0 or i == total_urls - 1:
                print(f"Processing URL {i+1}/{total_urls}...")
            
            # 단일 URL 처리
            result = process_url(url, interval_time)
            results.append(result)
            
            # batch_size마다 중간 결과 저장
            if (i + 1) % batch_size == 0 or i == total_urls - 1:
                current_df = pd.DataFrame(results)
                current_df.to_csv(output_path, index=False, encoding='utf-8')
                print(f"Saved {len(results)} results to: {output_path}")

    # 루프 종료 후 전체 처리 시간 계산
    process_end_time = time.time()
    total_process_time = process_end_time - process_start_time
    
    # Create DataFrame with results
    df = pd.DataFrame(results)

    # Calculate statistics
    df = pd.DataFrame(results)
    
    # Calculate average processing time
    avg_time_all = df['processing_time_sec'].mean()
    avg_time_google_only = df[df['status'] != 'SKIPPED']['processing_time_sec'].mean() if any(df['status'] != 'SKIPPED') else 0
    
    # 요약 통계
    success_count = df['status'].eq('SUCCESS').sum()
    failed_count = df['status'].eq('FAILED').sum()
    error_count = df['status'].eq('ERROR').sum() if 'ERROR' in df['status'].values else 0
    skipped_count = df['status'].eq('SKIPPED').sum()
    
    # 총 오류 수 (실패 + 기타 오류)
    total_errors = failed_count + error_count
    
    # Format time durations for display
    def format_time(seconds):
        if seconds < 60:
            return f"{seconds:.2f} seconds"
        else:
            return str(timedelta(seconds=round(seconds)))
    
    print(f"\n====== SUMMARY ======")
    print(f"Total URLs processed: {total_urls}")
    print(f"Workers used: {workers}")
    print(f"Successfully decoded: {success_count} ({success_count/total_urls*100:.1f}%)")
    print(f"Failed to decode: {failed_count} ({failed_count/total_urls*100:.1f}%)")
    if error_count > 0:
        print(f"Unexpected errors: {error_count} ({error_count/total_urls*100:.1f}%)")
    print(f"Total errors: {total_errors} ({total_errors/total_urls*100:.1f}%)")
    print(f"Skipped (non-Google News): {skipped_count} ({skipped_count/total_urls*100:.1f}%)")
    print(f"\n----- TIMING INFORMATION -----")
    print(f"Total processing time: {format_time(total_process_time)}")
    print(f"Average processing time per URL: {format_time(avg_time_all)}")
    print(f"Average processing time per Google News URL: {format_time(avg_time_google_only)}")
    print(f"Fastest URL processing time: {format_time(df['processing_time_sec'].min())}")
    print(f"Slowest URL processing time: {format_time(df['processing_time_sec'].max())}")
    print(f"=====================")
    
    # Add summary information to the DataFrame as metadata
    df.attrs['total_process_time'] = total_process_time
    df.attrs['avg_processing_time'] = avg_time_all
    df.attrs['avg_google_url_time'] = avg_time_google_only
    df.attrs['workers_used'] = workers
    
    return df

def process_url(url, interval_time=1):
    """단일 URL을 처리하고 결과를 반환하는 함수"""
    url_start_time = time.time()
    
    try:
        if "news.google.com" in url:
            try:
                decoded_result = gnewsdecoder(url, interval=interval_time)
                if decoded_result.get("status"):
                    status = "SUCCESS"
                    decoded_url = decoded_result["decoded_url"]
                    error_message = ""
                else:
                    status = "FAILED"
                    decoded_url = "N/A"
                    error_message = decoded_result.get("message", "Unknown error")
            except Exception as e:
                status = "FAILED"
                decoded_url = "N/A"
                error_message = str(e)
        else:
            # For non-Google News URLs
            status = "SKIPPED"
            decoded_url = url  # Keep the same URL
            error_message = "Not a Google News URL"
        
        # Calculate processing time for this URL
        url_end_time = time.time()
        processing_time = url_end_time - url_start_time
        
        # Return result as dictionary
        return {
            "original_url": url,
            "decoded_url": decoded_url,
            "status": status,
            "error_message": error_message,
            "processing_time_sec": round(processing_time, 3)
        }
    except Exception as e:
        # Handle any unexpected errors
        url_end_time = time.time()
        processing_time = url_end_time - url_start_time
        
        return {
            "original_url": url,
            "decoded_url": "N/A",
            "status": "ERROR",
            "error_message": f"Unexpected error: {str(e)}",
            "processing_time_sec": round(processing_time, 3)
        }

if __name__ == "__main__":
    # 명령줄에서 인자를 받아 실행하기 위한 코드
    parser = argparse.ArgumentParser(description='Google News URL decoder')
    parser.add_argument('input_file_path', help='Path to the file containing URLs to decode')
    parser.add_argument('--output_dir', '-o', help='Output directory for results (default: same as input file)')
    parser.add_argument('--interval', '-i', type=int, default=1, help='Interval time between requests (default: 1)')
    parser.add_argument('--batch_size', '-b', type=int, default=10, help='Batch size for saving interim results (default: 10)')
    parser.add_argument('--workers', '-w', type=int, default=1, help='Number of worker threads for parallel processing (default: 1)')
    
    args = parser.parse_args()
    
    # 인자 출력
    print(f"Processing URLs from: {args.input_file_path}")
    print(f"Output directory: {args.output_dir or 'Same as input file'}")
    print(f"Interval time: {args.interval}")
    print(f"Batch size: {args.batch_size}")
    print(f"Workers: {args.workers} (Parallel: {'Enabled' if args.workers > 1 else 'Disabled'})")
    
    # 함수 실행
    result = process_urls_from_file(
        args.input_file_path, 
        args.output_dir, 
        args.interval, 
        args.batch_size,
        args.workers
    )
    
    # 결과 반환
    if result is not None:
        print(f"Process completed successfully. Results saved to CSV file.")
    else:
        print(f"Process failed. Please check error messages above.")

예시 Python 스크립트 펼치기

from googlenewsdecoder import gnewsdecoder
import pandas as pd
import os
import time
import argparse
import concurrent.futures
from datetime import datetime, timedelta

def process_urls_from_file(input_file_path, output_dir=None, interval_time=1, batch_size=10, workers=1):
    """
    파일에서 URL을 읽고 처리하는 함수
    
    Args:
        input_file_path: URL이 포함된 파일 경로
        output_dir: 결과 저장 디렉토리 (기본값: 입력 파일과 동일)
        interval_time: URL 처리 사이의 대기 시간 (초)
        batch_size: 중간 결과 저장 단위 (URL 개수)
        workers: 병렬 처리를 위한 작업자 수 (기본값: 1, 병렬 처리 없음)
        
    Returns:
        처리 결과가 포함된 DataFrame 또는 오류 시 None
    """
    # Read URLs from file
    try:
        # 파일 확장자 확인
        file_ext = os.path.splitext(input_file_path)[1].lower()
        
        if file_ext == '.csv':
            # CSV 파일인 경우 pandas로 읽기
            try:
                df = pd.read_csv(input_file_path, encoding='utf-8-sig')
                
                # 'link' 컬럼이 있는지 확인
                if 'link' in df.columns:
                    urls = df['link'].dropna().tolist()
                    print(f"Found {len(urls)} URLs in 'link' column")
                else:
                    available_columns = ', '.join(df.columns)
                    print(f"Error: 'link' column not found in CSV. Available columns: {available_columns}")
                    return None
            except Exception as e:
                print(f"Error parsing CSV file: {e}")
                return None
        else:
            # 일반 텍스트 파일로 간주하고 한 줄에 하나의 URL로 읽기
            with open(input_file_path, 'r', encoding='utf-8-sig') as file:
                urls = [line.strip() for line in file if line.strip()]
                print(f"Found {len(urls)} URLs in text file")
    except Exception as e:
        print(f"Error reading file: {e}")
        return None

    # 파일 저장 기본 설정
    if output_dir is None:
        output_dir = os.path.dirname(input_file_path) or '.'
    
    timestamp = datetime.now().strftime("%Y-%m-%d_%H%M%S")
    input_filename = os.path.basename(input_file_path).split('.')[0]
    output_filename = f"{input_filename}_decoded_{timestamp}.csv"
    output_path = os.path.join(output_dir, output_filename)
    
    print(f"Results will be saved to: {output_path}")
    
    # Process each URL
    results = []
    total_urls = len(urls)
    
    print(f"Starting to process {total_urls} URLs...")
    print(f"Workers: {workers} (Parallel processing: {'Enabled' if workers > 1 else 'Disabled'})")

    # Record overall process start time
    process_start_time = time.time()
    
    # 병렬 처리 사용 여부에 따라 처리 방식 결정
    if workers > 1:
        # 병렬 처리 사용
        completed = 0
        
        # URL 배치로 나누기 (한 번에 batch_size만큼 병렬 처리)
        for batch_start in range(0, total_urls, batch_size):
            batch_end = min(batch_start + batch_size, total_urls)
            batch_urls = urls[batch_start:batch_end]
            batch_size_actual = len(batch_urls)
            
            print(f"Processing URLs {batch_start+1}-{batch_end} of {total_urls}...")
            
            # 병렬 처리 실행
            with concurrent.futures.ThreadPoolExecutor(max_workers=workers) as executor:
                # URL을 병렬로 처리
                future_to_url = {executor.submit(process_url, url, interval_time): url for url in batch_urls}
                
                # 결과 수집
                for future in concurrent.futures.as_completed(future_to_url):
                    result = future.result()
                    results.append(result)
                    completed += 1
                    
                    # 진행 상황 표시 (10개마다 또는 배치 완료 시)
                    if completed % 10 == 0 or completed == total_urls:
                        print(f"Processed {completed}/{total_urls} URLs...")
            
            # 현재 배치의 결과를 CSV 파일로 저장
            current_df = pd.DataFrame(results)
            current_df.to_csv(output_path, index=False, encoding='utf-8')
            print(f"Saved {len(results)} results to: {output_path}")
    else:
        # 직렬 처리 사용 (기존 방식)
        for i, url in enumerate(urls):
            if i % 10 == 0 or i == total_urls - 1:
                print(f"Processing URL {i+1}/{total_urls}...")
            
            # 단일 URL 처리
            result = process_url(url, interval_time)
            results.append(result)
            
            # batch_size마다 중간 결과 저장
            if (i + 1) % batch_size == 0 or i == total_urls - 1:
                current_df = pd.DataFrame(results)
                current_df.to_csv(output_path, index=False, encoding='utf-8')
                print(f"Saved {len(results)} results to: {output_path}")

    # 루프 종료 후 전체 처리 시간 계산
    process_end_time = time.time()
    total_process_time = process_end_time - process_start_time
    
    # Create DataFrame with results
    df = pd.DataFrame(results)

    # Calculate statistics
    df = pd.DataFrame(results)
    
    # Calculate average processing time
    avg_time_all = df['processing_time_sec'].mean()
    avg_time_google_only = df[df['status'] != 'SKIPPED']['processing_time_sec'].mean() if any(df['status'] != 'SKIPPED') else 0
    
    # 요약 통계
    success_count = df['status'].eq('SUCCESS').sum()
    failed_count = df['status'].eq('FAILED').sum()
    error_count = df['status'].eq('ERROR').sum() if 'ERROR' in df['status'].values else 0
    skipped_count = df['status'].eq('SKIPPED').sum()
    
    # 총 오류 수 (실패 + 기타 오류)
    total_errors = failed_count + error_count
    
    # Format time durations for display
    def format_time(seconds):
        if seconds < 60:
            return f"{seconds:.2f} seconds"
        else:
            return str(timedelta(seconds=round(seconds)))
    
    print(f"\n====== SUMMARY ======")
    print(f"Total URLs processed: {total_urls}")
    print(f"Workers used: {workers}")
    print(f"Successfully decoded: {success_count} ({success_count/total_urls*100:.1f}%)")
    print(f"Failed to decode: {failed_count} ({failed_count/total_urls*100:.1f}%)")
    if error_count > 0:
        print(f"Unexpected errors: {error_count} ({error_count/total_urls*100:.1f}%)")
    print(f"Total errors: {total_errors} ({total_errors/total_urls*100:.1f}%)")
    print(f"Skipped (non-Google News): {skipped_count} ({skipped_count/total_urls*100:.1f}%)")
    print(f"\n----- TIMING INFORMATION -----")
    print(f"Total processing time: {format_time(total_process_time)}")
    print(f"Average processing time per URL: {format_time(avg_time_all)}")
    print(f"Average processing time per Google News URL: {format_time(avg_time_google_only)}")
    print(f"Fastest URL processing time: {format_time(df['processing_time_sec'].min())}")
    print(f"Slowest URL processing time: {format_time(df['processing_time_sec'].max())}")
    print(f"=====================")
    
    # Add summary information to the DataFrame as metadata
    df.attrs['total_process_time'] = total_process_time
    df.attrs['avg_processing_time'] = avg_time_all
    df.attrs['avg_google_url_time'] = avg_time_google_only
    df.attrs['workers_used'] = workers
    
    return df

def process_url(url, interval_time=1):
    """단일 URL을 처리하고 결과를 반환하는 함수"""
    url_start_time = time.time()
    
    try:
        if "news.google.com" in url:
            try:
                decoded_result = gnewsdecoder(url, interval=interval_time)
                if decoded_result.get("status"):
                    status = "SUCCESS"
                    decoded_url = decoded_result["decoded_url"]
                    error_message = ""
                else:
                    status = "FAILED"
                    decoded_url = "N/A"
                    error_message = decoded_result.get("message", "Unknown error")
            except Exception as e:
                status = "FAILED"
                decoded_url = "N/A"
                error_message = str(e)
        else:
            # For non-Google News URLs
            status = "SKIPPED"
            decoded_url = url  # Keep the same URL
            error_message = "Not a Google News URL"
        
        # Calculate processing time for this URL
        url_end_time = time.time()
        processing_time = url_end_time - url_start_time
        
        # Return result as dictionary
        return {
            "original_url": url,
            "decoded_url": decoded_url,
            "status": status,
            "error_message": error_message,
            "processing_time_sec": round(processing_time, 3)
        }
    except Exception as e:
        # Handle any unexpected errors
        url_end_time = time.time()
        processing_time = url_end_time - url_start_time
        
        return {
            "original_url": url,
            "decoded_url": "N/A",
            "status": "ERROR",
            "error_message": f"Unexpected error: {str(e)}",
            "processing_time_sec": round(processing_time, 3)
        }

if __name__ == "__main__":
    # 명령줄에서 인자를 받아 실행하기 위한 코드
    parser = argparse.ArgumentParser(description='Google News URL decoder')
    parser.add_argument('input_file_path', help='Path to the file containing URLs to decode')
    parser.add_argument('--output_dir', '-o', help='Output directory for results (default: same as input file)')
    parser.add_argument('--interval', '-i', type=int, default=1, help='Interval time between requests (default: 1)')
    parser.add_argument('--batch_size', '-b', type=int, default=10, help='Batch size for saving interim results (default: 10)')
    parser.add_argument('--workers', '-w', type=int, default=1, help='Number of worker threads for parallel processing (default: 1)')
    
    args = parser.parse_args()
    
    # 인자 출력
    print(f"Processing URLs from: {args.input_file_path}")
    print(f"Output directory: {args.output_dir or 'Same as input file'}")
    print(f"Interval time: {args.interval}")
    print(f"Batch size: {args.batch_size}")
    print(f"Workers: {args.workers} (Parallel: {'Enabled' if args.workers > 1 else 'Disabled'})")
    
    # 함수 실행
    result = process_urls_from_file(
        args.input_file_path, 
        args.output_dir, 
        args.interval, 
        args.batch_size,
        args.workers
    )
    
    # 결과 반환
    if result is not None:
        print(f"Process completed successfully. Results saved to CSV file.")
    else:
        print(f"Process failed. Please check error messages above.")

️ 실행결과

성능 평가 및 결과

병렬 처리를 적용한 결과, 다음과 같은 성능 향상을 확인하였다.

성능 지표	순차 처리 (Sequential)	병렬 처리 (Parallel)	비교 결과
총 처리 시간 (500개 URL)	26분 57초	5분 12초	약 5배 빠름
평균 개별 처리 시간	3초	3초	차이 없음
전체 처리 효율성	낮음 (순차 대기)	높음 (동시 처리)	5배 향상
성공률	100%	100%	동일
사용된 작업자 수	1개	5개	병렬 처리 활용

마무리

googlenewsdecoder는 복잡한 구글 뉴스 URL 리디렉션 문제를 간단히 해결할 수 있는 유용한 도구로 이를 병렬 처리와 결합하면 처리 속도를 획기적으로 향상시킬 수 있다. 이제 원문 기사 주소를 알아내었으니, 기사 내용을 추출하는 단계로 넘어가겠다. 다음 글에서는 대량 기사 크롤링 전략을 다룰 예정이다.

Googlenewsdecoder: 구글 뉴스 RSS 링크를 원문 주소로 변경해주는 도구

catalystmind — Sat, 24 May 2025 22:32:31 +0900

TL;DR

googlenewsdecoder는 Google News RSS 피드의 리디렉션 URL을 원래 주소로 복원해주는 Python 도구임
URL 약 300개 처리 결과,
- URL 하나 처리 시간은 평균 약 3초,
- 정확도 100%로 現 시점에는 안정적으로 변환 가능한것으로 판단함
자동화 시스템과 연동하여 뉴스 수집 및 분석 워크플로우를 효율화할 수 있음

지난 글에서 구글 뉴스 RSS의 복잡한 리디렉션 구조를 설명하며 성공적인 뉴스 본문 추출을 위해서는 원문 URL의 필요성을 강조했다. 이번 글에서는 googlenewsdecoder의 기능과 사용법, 성능(처리 시간 및 정확도)에 대해서 설명하고자 한다.

googlenewsdecoder란?

googlenewsdecoder는 이름에서도 알 수 있듯, Google 뉴스 RSS에서 제공되는 리디렉션 URL을 실제 뉴스 원문 URL로 변환해 주는 편리한 파이썬 라이브러리다.

⚠️ googlenewsdecode 사용 시 주의할 점

구글의 URL 형식이 변경되면 언제든 작동하지 않을 수 있다.
Google 서버와의 실시간 통신이 필수이므로 인터넷 연결이 반드시 필요하다.

기본 사용법

Python

from googlenewsdecoder import gnewsdecoder

def main():
    interval_time = 1  # interval is optional, default is None
    source_url = "https://news.google.com/rss/articles/CBMiYkFVX3lxTFBlb0FfcmFmQUZybGF6NXFNNmNhd2NwZjc5NlZ4NkZZUEdqckVERFJZck05OEk5VnhOS1JzTTNnMDlxc1RSdW1xRzhTNFNNTEl1d0RqWDNKWTB6cUxIMGlrM3dR0gFkQVVfeXFMTkcyUEtwTEhtQUNQMGZZYTZnZVFLWTZDZDNhU1ZlUHl2OVVRNGhuRDNQZDNZQXVRS1FHS01peGZJRmlDd3NVX0k1ZmdlM0M0RzRRN1lRMVhfNmtoYnprM0VyMXoyWg?oc=5"
    try:
        decoded_url = gnewsdecoder(source_url, interval=interval_time)
        if decoded_url.get("status"):
            print("Decoded URL:", decoded_url["decoded_url"])
        else:
            print("Error:", decoded_url["message"])
    except Exception as e:
        print(f"Error occurred: {e}")

if __name__ == "__main__":
    main()

️ 출력 예시:

Decoded URL: https://www.moneys.co.kr/article/2025050209420281578

파일 기반 다중 URL 처리

하루에 많게는 종목당 약 30개의 주식 관련 뉴스가 쏟아진다. 이것들을 Powerautomate의 반복문을 이용해 처리하는 것은 매우 비효율적이므로, 파이썬 스크립트를 활용하여 수집한 모든 URL을 한번에 처리하는 방식이 효율적이다. 기본 코드에 1. 파일을 읽고 2. 결과를 CSV로 저장하는 코드를 추가하고 3. googlenewsdecoder의 성능을 분석하기 위한 코드가 추가되었다.

사용 방법

Powershell에서 실행 방법:

python googlenewsdecoder_external.py urls.txt --output_dir ./results --interval 1 --batch_size 10

input_file_path: 입력 파일 경로 (필수)
--output_dir (-o): 결과를 저장할 디렉토리 (선택, 기본값은 입력 파일과 동일)
--interval (-i): 각 요청 간의 시간 간격 (초 단위, 기본값은 1초)
--batch_size (-b): 처리한 결과를 몇 개씩 나누어 저장할지 설정 (기본값은 10)

전체 파이썬 스크립트는 다음과 같다.

Python

from googlenewsdecoder import gnewsdecoder
import pandas as pd
import os
import time
import argparse
from datetime import datetime, timedelta

def process_urls_from_file(input_file_path, output_dir=None, interval_time=1, batch_size=10):
    # Read URLs from file
    try:
        # 파일 확장자 확인
        file_ext = os.path.splitext(input_file_path)[1].lower()
        
        if file_ext == '.csv':
            # CSV 파일인 경우 pandas로 읽기
            try:
                df = pd.read_csv(input_file_path, encoding='utf-8-sig')
                
                # 'link' 컬럼이 있는지 확인
                if 'link' in df.columns:
                    urls = df['link'].dropna().tolist()
                    print(f"Found {len(urls)} URLs in 'link' column")
                else:
                    available_columns = ', '.join(df.columns)
                    print(f"Error: 'link' column not found in CSV. Available columns: {available_columns}")
                    return None
            except Exception as e:
                print(f"Error parsing CSV file: {e}")
                return None
        else:
            # 일반 텍스트 파일로 간주하고 한 줄에 하나의 URL로 읽기
            with open(input_file_path, 'r', encoding='utf-8-sig') as file:
                urls = [line.strip() for line in file if line.strip()]
                print(f"Found {len(urls)} URLs in text file")
    except Exception as e:
        print(f"Error reading file: {e}")
        return None

    # 파일 저장 기본 설정
    if output_dir is None:
        output_dir = os.path.dirname(input_file_path) or '.'
    
    timestamp = datetime.now().strftime("%Y-%m-%d_%H%M%S")
    input_filename = os.path.basename(input_file_path).split('.')[0]
    output_filename = f"{input_filename}_decoded_{timestamp}.csv"
    output_path = os.path.join(output_dir, output_filename)
    
    print(f"Results will be saved to: {output_path}")
    
    # Process each URL
    results = []
    total_urls = len(urls)
    
    print(f"Starting to process {total_urls} URLs...")

    # Record overall process start time
    process_start_time = time.time()

    for i, url in enumerate(urls):
        if i % 10 == 0 or i == total_urls - 1:
            print(f"Processing URL {i+1}/{total_urls}...")
        
        # Record start time for this URL
        url_start_time = time.time()
        
        if "news.google.com" in url:
            try:
                decoded_result = gnewsdecoder(url, interval=interval_time)
                if decoded_result.get("status"):
                    status = "SUCCESS"
                    decoded_url = decoded_result["decoded_url"]
                    error_message = ""
                else:
                    status = "FAILED"
                    decoded_url = "N/A"
                    error_message = decoded_result.get("message", "Unknown error")
            except Exception as e:
                status = "FAILED"
                decoded_url = "N/A"
                error_message = str(e)
        else:
            # For non-Google News URLs
            status = "SKIPPED"
            decoded_url = url  # Keep the same URL
            error_message = "Not a Google News URL"
        
        # Calculate processing time for this URL
        url_end_time = time.time()
        processing_time = url_end_time - url_start_time
        
        # Add to results
        results.append({
            "original_url": url,
            "decoded_url": decoded_url,
            "status": status,
            "error_message": error_message,
            "processing_time_sec": round(processing_time, 3)
        })
        
        # 10개마다 중간 결과 저장
        if (i + 1) % batch_size == 0 or i == total_urls - 1:
            current_df = pd.DataFrame(results)
            current_df.to_csv(output_path, index=False, encoding='utf-8')
            print(f"Saved {len(results)} results to: {output_path}")

    # 루프 종료 후 전체 처리 시간 계산
    process_end_time = time.time()
    total_process_time = process_end_time - process_start_time
    
    # Create DataFrame with results
    df = pd.DataFrame(results)

    # Calculate average processing time
    avg_time_all = df['processing_time_sec'].mean()
    avg_time_google_only = df[df['status'] != 'SKIPPED']['processing_time_sec'].mean() if any(df['status'] != 'SKIPPED') else 0
    
    # 요약 통계
    success_count = df['status'].eq('SUCCESS').sum()
    failed_count = df['status'].eq('FAILED').sum()
    skipped_count = df['status'].eq('SKIPPED').sum()
    
    # Format time durations for display
    def format_time(seconds):
        if seconds < 60:
            return f"{seconds:.2f} seconds"
        else:
            return str(timedelta(seconds=round(seconds)))
    
    print(f"\n====== SUMMARY ======")
    print(f"Total URLs processed: {total_urls}")
    print(f"Successfully decoded: {success_count} ({success_count/total_urls*100:.1f}%)")
    print(f"Failed to decode: {failed_count} ({failed_count/total_urls*100:.1f}%)")
    print(f"Skipped (non-Google News): {skipped_count} ({skipped_count/total_urls*100:.1f}%)")
    print(f"\n----- TIMING INFORMATION -----")
    print(f"Total processing time: {format_time(total_process_time)}")
    print(f"Average processing time per URL: {format_time(avg_time_all)}")
    print(f"Average processing time per Google News URL: {format_time(avg_time_google_only)}")
    print(f"Fastest URL processing time: {format_time(df['processing_time_sec'].min())}")
    print(f"Slowest URL processing time: {format_time(df['processing_time_sec'].max())}")
    print(f"=====================")
    
    # Add summary information to the DataFrame as metadata
    df.attrs['total_process_time'] = total_process_time
    df.attrs['avg_processing_time'] = avg_time_all
    df.attrs['avg_google_url_time'] = avg_time_google_only
    
    return df

# run_url_decoder 함수를 제거하였습니다.

if __name__ == "__main__":
    # 명령줄에서 인자를 받아 실행하기 위한 코드
    parser = argparse.ArgumentParser(description='Google News URL decoder')
    parser.add_argument('input_file_path', help='Path to the file containing URLs to decode')
    parser.add_argument('--output_dir', '-o', help='Output directory for results (default: same as input file)')
    parser.add_argument('--interval', '-i', type=int, default=1, help='Interval time between requests (default: 1)')
    parser.add_argument('--batch_size', '-b', type=int, default=10, help='Batch size for saving interim results (default: 10)')
    
    args = parser.parse_args()
    
    # 인자 출력
    print(f"Processing URLs from: {args.input_file_path}")
    print(f"Output directory: {args.output_dir or 'Same as input file'}")
    print(f"Interval time: {args.interval}")
    print(f"Batch size: {args.batch_size}")
    
    # 함수 실행
    result = process_urls_from_file(
        args.input_file_path, 
        args.output_dir, 
        args.interval, 
        args.batch_size
    )
    
    # 결과 반환
    if result is not None:
        print(f"Process completed successfully. Results saved to CSV file.")
    else:
        print(f"Process failed. Please check error messages above.")

️ 실행결과

성능 평가 및 결과

성능 평가 결과는 다음과 같다:

총 처리 시간: 26분 57초
평균 처리 시간: 3.23초이며, 대부분 3.0-3.5초 구간에 집중되어 있음.
정확도: 총 500개의 URL이 분석되었으며, 성공률은 100.00%
msn과 같은 까다로운 url도 성공함

마무리

googlenewsdecoder는 구글 뉴스 RSS 링크를 원문 URL로 변환하는 도구로 기사 본문 추출에 중요한 역할을 한다. 까다로운 URL 리디렉션을 간편하게 해결하여 기사 수집 자동화를 위한 원문 접근성을 높여준다. 이번 글에는 반복문을 사용하여 순차적으로 변환하였으나, 병렬 처리를 적용하면 속도를 더 높일 수 있다. 다음 글에는 concurrent.futures 패키지를 이용한 병렬처리로 시간을 더 단축하는 방법을 알아보겠다.

Google 뉴스 RSS 링크 분석: 본문 추출을 위한 URL 처리 전략 2가지

catalystmind — Tue, 20 May 2025 20:25:38 +0900

TL;DR

구글 뉴스 RSS에서 제공하는 링크는 실제 뉴스 페이지가 아닌 리디렉션 URL임
이 링크는 URL-safe base64와 protobuf 형식으로 인코딩되어 있어 직접 처리가 어려움
본문 추출을 위한 두 가지 접근법: ①오픈소스 패키지 활용과 ②브라우저 자동화(Playwright)
두 방법 모두 장단점이 있으며, 어떤 것을 사용할지는 각자의 상황에 맞게 선택해야 함
앞으로의 글에서 각 방법의 구체적인 구현 방법과 성과를 다룰 예정

구글 뉴스 RSS 링크: 리디렉션 URL과 본문 추출의 시작

RSS로 수집한 기사 주소를 보면 알겠지만, 사람이 읽고 이해할 수 있는 형태가 아니다. Google이 제공하는 URL을 클릭하면 실제 뉴스 사이트로 이동하지만, 이 주소는 원문 사이트 주소가 아니다. trafilatura는 웹에서 바로 정보를 가져와서 본문을 추출하는 기능이 있지만, 이 URL을 직접 입력하면 작동하지 않는다. 이 주소를 원문 사이트 주소로 바꿔주어야 정상 작동하는 것을 알 수 있다.

Python 구글 URL입력

import trafilatura
url = "https://news.google.com/rss/articles/CBMicEFVX3lxTFBpYk5ZakJVbWRmaW5MLW1Da1pNUEc2dG5uTHdsZXFWSDFFMXVRVF9qajVyYllpNjFmRWR6TnpwQktka0hpTUdURVlLdXdLc3FSQ0hpTlkwSm5uSjlZRnNxZzRyekE4dE1MSENDRno3SWvSAXRBVV95cUxNdXBTR0NLMHVaTEZHb3pGME1BdGNwNjVBNTJzTDd6U1RHbzJCbDlhbmpYMXZ1Tk00M3N5YkxXWTF1Q1FqUXl5X2Z4TC0ycnBxZmVEclEzazRmcmtMY0szaVN5c3dWRWwtemZhNjJNVGZFWEJGVQ?oc=5"
html = trafilatura.fetch_url(url)
text = trafilatura.extract(html)
text

Python 원본 URL 입력

import trafilatura
url = "https://www.steeldaily.co.kr/news/articleView.html?idxno=191742"
html = trafilatura.fetch_url(url)
text = trafilatura.extract(html)
text

Output 실행 결과

'대구경 강관 전문 제조 기업 동양철관의 1분기 매출 및 영업이익은 전년 동기 대비 동반 축소된 것으로 나타났다.
동양철관은 15일 금융감독원에 분기보고서를 제출하고 1분기 별도 기준 경영 실적에 대해 △매출액 329억 5,100만 원(전년 동기 대비 44.9% 감소) △영업손실 4억 2,900만 원(적자전환) △순손실 15억 6,000만 원(적자전환)을 기록했다고 밝혔다.
이로써 1분기 연결 실적은 매출액 436억 5,800만 원(전년 동기 대비 36% 감소), 영업손실 2,900만 원(적자전환), 순손실 12억 600만 원(적자전환)으로 집계됐다.
이명화 선임기자
lmh@steelnsteel.co.kr'

❌ 왜 Google 링크를 사용하면 본문 추출이 작동하지 않을까?

보안 및 트래픽 추적

사용자의 클릭 기록 및 인기 기사 분석을 위해 리디렉션 URL과 추적 매개변수 활용

⚙️

복잡한 데이터 인코딩

원문 URL을 Protobuf 형식으로 직렬화하고 URL-safe Base64로 인코딩

타임스탬프와 서명 인증

리디렉션 요청의 유효성을 검증하는 signature 및 timestamp 포함

진화하는 보안 메커니즘

스크립트나 봇 차단을 위해 URL 구조와 데이터 인코딩 지속적 변화

Google 뉴스 리디렉션 URL 상세 내용 ▼

Google이 제공하는 이 URL은 실제 뉴스 기사 페이지가 아니라, Google 서버를 거쳐 리디렉션되는 중간 링크이다. 이 구조는 다음과 같은 이유로 설계되어 있다:

1. 보안 및 트래픽 추적:

Google은 사용자의 클릭을 추적하여 어떤 뉴스가 인기 있는지, 클릭률이 어떻게 형성되는지를 분석한다. 이를 위해 리디렉션 URL과 추가 추적 매개변수(예: url, ref, v, ptok, ei, ctid 등)를 사용하여 사용자의 이동 경로를 기록한다.

2. 원문 보호 및 복잡한 데이터 인코딩:

이 중간 주소에는 원문 URL을 포함한 다양한 정보가 Google의 프로토콜 버퍼(Protobuf) 형식으로 직렬화된 후, URL-safe Base64로 인코딩되어 URL 매개변수에 포함될 가능성이 높다. 이러한 직렬화 및 Base64 인코딩은 해당 형식을 알지 못하면 Base64 디코딩만으로는 원문 링크를 포함한 의미 있는 정보를 직접 파악하는 것을 매우 어렵게 만든다.

3. 타임스탬프와 서명 기반 인증 시스템:

최근 Google의 리디렉션 주소는 더욱 복잡해졌으며, URL에는 리디렉션 요청의 유효성을 Google 서버 측에서 검증하기 위해 사용될 가능성이 높은 "signature" (sig 또는 유사한 이름), "timestamp" (ts 또는 유사한 이름), "gn_art_id" (id 또는 유사한 이름)와 같은 매개변수가 포함될 수 있다. 이러한 서명 및 검증 정보는 클라이언트가 원문 URL을 직접 디코딩하는 데 필요한 정보라기보다는, Google 서버가 리디렉션 요청을 처리할 때 유효성을 확인하는 데 사용된다. 따라서 정상적인 리디렉션 처리를 위해서는 이러한 매개변수가 포함된 요청이 Google 서버로 전송되어야 한다.

4. 진화하는 보안 메커니즘:

초기에는 간단한 Base64 디코딩만으로 원문 URL의 일부를 추출할 수 있었을 수도 있지만, Google은 자동화된 스크립트나 봇의 대량 정보 추출을 방지하기 위해 지속적으로 URL 구조, 데이터 인코딩 방식, 추적 메커니즘 등을 변경하고 복잡하게 만들고 있다. 최근에는 대량의 리디렉션 요청을 감지하고 차단하는 비율 제한(rate limiting) 메커니즘이 적용될 수 있으며, 이를 우회하려는 시도에는 프록시 서버 사용 등의 더욱 복잡한 기술적 접근이 필요해지고 있다.

요약하자면, Google은 원문 주소를 외부에 직접 노출하지 않도록 설계했고, 중간 주소를 역으로 복호화하거나 디코딩하는 방식이 점점 더 복잡해지고 있다.

✅ 본문 추출을 위한 두 가지 접근법

Google News RSS 링크에서 실제 뉴스 본문을 추출하기 위한 두 가지 주요 전략이 존재한다. 이 글에서는 간략히 두 방법을 소개하고, 앞으로의 글에서 각 방법을 다룰 예정이다.

본문 추출을 위한 두 가지 접근법

패키지 활용 방식

복잡한 URL

↓

오픈소스 패키지

↓

✅

원본 URL 추출 완료

↓

최종 뉴스 페이지 접속

↓

본문 추출

직접 URL 해독

브라우저 자동화 방식

복잡한 URL

↓

자동화 브라우저 접속

↓

리디렉션 진행

↓

최종 뉴스 페이지 도착

↓

HTML 저장

↓

본문 추출

Google 처리 과정 모방

앞으로 다룰 내용

이번 글에서는 Google News RSS 링크의 특징과 본문 추출을 위한 두 가지 기본 접근법을 소개했다. 앞으로의 글에서는 다음의 주제들을 다룰 예정이다:

1️⃣Google News URL 간단히 처리하기: 오픈소스 패키지 활용

복잡한 디코딩 과정 없이 원문 URL 해결하기
병렬 처리로 대량 URL 처리 최적화 방법
본문 추출 도구 적용 방법

2️⃣Playwright를 활용한 Google News 본문 추출 자동화

Playwright vs Selenium 비교 및 Playwright 선택 이유
효율적인 브라우저 자동화 설정
Playwright의 비동기 처리를 통한 성능 향상
본문 추출 도구 적용 방법

3️⃣두 방법의 실전 비교: 어떤 상황에 어떤 방법이 적합한가

속도, 정확도, 리소스 사용량 비교
대규모 배치 처리와 실시간 처리의 차이
통계적 유의미성을 위한 최소 표본 크기(300-500개 기사)

마치며

Google News RSS에서 수집된 링크는 원문 뉴스 URL이 아니며, Google의 복잡한 리디렉션 구조를 따르는 중간 링크다. 이 링크를 이용해서 실제 뉴스 본문을 추출하기 위해서는 오픈소스 패키지를 활용한 URL 변환 방식과 브라우저 자동화 방식이라는 두 가지 접근법이 존재한다.

다음 글에서는 첫 번째 방법인 오픈소스 패키지 활용 접근법에 대해 살펴보고, 코드로 구현하는 방법과 결과를 알아볼 예정이다.

Power Automate + feedparser 개선: Google 뉴스 수집 속도 단축하기

catalystmind — Sun, 18 May 2025 10:43:14 +0900

TL;DR

기존 방식은 Power Automate로 XML 파일 저장 후 feedparser로 처리함
개선 방식은 feedparser가 Google News RSS를 직접 파싱하도록 변경해 프로세스 단계 1개 제거 및 처리 시간 41.3% 단축함
한글/특수문자 URL 파싱 실패 문제는 Python urllib.parse.quote() 함수로 URL 인코딩 적용해 해결함
이 코드는 검색어 기반 RSS URL 자동 생성 및 기사 제목/링크/발행일 추출 기능을 구현함
이 코드는 Power Automate와 연동해 완전 자동화된 뉴스 수집에 적용될 예정

앞에서 소개한 Power Automate를 활용한 방식은 Power Automate로 xml 파일 10개를 저장하고 이를 다시 feedparser로 처리하는 방식이었다. Feedparser는 url 주소을 입력하면, 직접 웹에서 정보를 가져와 처리할 수 있으므로, 불필요한 단계를 하나 더 제거하고자 코드를 수정하였다. 먼저, 결과는 다음과 같다.

기존 프로세스

KRX 거래량 상위 종목 추출

사용 도구: PAD

소요 시간: 12초

XML 파일 저장 10개

사용 도구: PAD

소요 시간: 65초

구글 URL 추출

사용 도구: feedparser

소요 시간: 3초

총 소요시간: 80초

개선된 프로세스

KRX 거래량 상위 종목 추출

사용 도구: PAD

소요 시간: 12초

웹에서 직접 구글 URL 추출 10개

사용 도구: feedparser

소요 시간: 35초

총 소요시간: 47초

프로세스 개선 효과: 시간 33초 절약 (41.3%), 단계 1개 감소, PAD 사용 1회 감소

feedparser 사용 시 URL 인코딩의 중요성 - urllib.parse

feedparser는 URL을 직접 입력받아 웹에서 RSS 정보를 실시간으로 가져와 처리할 수 있지만, URL을 입력할 때는 특별한 주의가 필요하다. 우리가 브라우저 주소창에서 보는 URL과 실제로 서버에 전달되는 URL은 다르기 때문이다.

예를 들어, 구글 뉴스에서 "에코프로"를 검색하면 브라우저 주소창에는 우리가 읽을 수 있는 형태로 다음과 같이 표시된다.

https://news.google.com/search?q="에코프로"&hl=ko&gl=KR&ceid=KR%3Ako

하지만, 이 URL을 복사하여 붙여보면 실제로는 다음과 같이 한글이 다른 문자로 변환되어 있음을 확인할 수 있다.

https://news.google.com/search?q=%22%EC%97%90%EC%BD%94%ED%94%84%EB%A1%9C%22&hl=ko&gl=KR&ceid=KR%3Ako

브라우저는 이러한 URL 변환 과정을 자동으로 처리하지만, feedparser에는 그런 기능이 없다. 따라서, 이 문제를 해결하기 위해 Python의 urllib.parse 모듈을 사용해야 하며, 이 모듈은 URL의 한글이나 특수문자를 올바르게 인코딩하여 웹 요청에 적합한 형태로 변환해준다.

urllib.parse 사용 예시

import urllib.parse

def get_rss_news_url(search_term):
    
    query = f'"{search_term}"'
           
    # URL 인코딩
    encoded_query = urllib.parse.quote(query)
    rss_url = f'https://news.google.com/rss/search?q={encoded_query}&hl=ko&gl=KR&ceid=KR%3Ako'
    return rss_url

def main():
    # 검색어 입력 받기
    search_term = input("검색어를 입력하세요: ")
    
    # URL 생성
    news_rss_url = get_rss_news_url(search_term)
    
    # 결과 출력
    print(f"\n생성된 Google News rss URL: {news_rss_url}")    

if __name__ == "__main__":
    main()

검색어를 입력하세요:  에코프로

생성된 Google News rss URL: https://news.google.com/rss/search?q=%22%EC%97%90%EC%BD%94%ED%94%84%EB%A1%9C%22&hl=ko&gl=KR&ceid=KR%3Ako

urllib.parse와 feedparser 결합

import urllib.parse
import feedparser

def get_rss_url(search_term):
    encoded_search_term = urllib.parse.quote(f'"{search_term}"')
    rss_url = f'https://news.google.com/rss/search?q={encoded_search_term}&hl=ko&gl=KR&ceid=KR%3Ako'
    return rss_url

def main():
    search_term = input("검색어를 입력하세요: ")
       
    # RSS 피드 URL 생성 (Google News는 검색결과를 RSS로도 제공)
    rss_url = get_rss_url(search_term)
    print(f"RSS URL: {rss_url}")
    
    # 잠시 대기
    time.sleep(2)
    
    # RSS 피드 파싱
    print("\nRSS 피드 파싱 중...")
    feed = feedparser.parse(rss_url)
       
    # 모든 기사 출력 (요약 없음)
    print("\n모든 기사:")
    for i, entry in enumerate(feed.entries, 1):
        print(f"\n{i}. {entry.title}")
        print(f"   링크: {entry.link}")
        print(f"   발행일: {entry.published if 'published' in entry else '날짜 정보 없음'}")

if __name__ == "__main__":
    main()

검색어를 입력하세요:  에코프로
RSS URL: https://news.google.com/rss/search?q=%22%EC%97%90%EC%BD%94%ED%94%84%EB%A1%9C%22&hl=ko&gl=KR&ceid=KR%3Ako

RSS 피드 파싱 중...

모든 기사:

1. [직장 돋보기 분석] 에코프로, 평균연봉 9500만원인 친환경 기술 기업...고연봉이지만 평균 근속연수는 3.8년 - 뉴스투데이
   링크: https://news.google.com/rss/articles/CBMiXkFVX3lxTE9reHNJcWMyNU1zdmNkN09qa1g1R1VmYW1Ic0VOa2xYZWR2RTRVOXZuVGpRVmZWMjU1OFdyRkdwRDJ6WXB2MWtkRl9USmxiMmdEaWpXdWs5N1g0bDdPTXc?oc=5
   발행일: Sat, 17 May 2025 03:00:00 GMT

2. 에코프로머티, 전구체 설비 계약 일정 조정…"투자 계획 변동 없어" - 전자부품 전문 미디어 디일렉
   링크: https://news.google.com/rss/articles/CBMiZkFVX3lxTFBKTmc0NGVHNFc4QmJybS1zLV9kUExFTE5BMHJjQXU3Y1BQa1JYdU9HLU8zNDFtdFRHZHdKa1VvZ2NybmlncHVvNDlCMGE2WVpCZWRfbXNrVEg4NkYwdWVyUFkyam84dw?oc=5
   발행일: Thu, 17 Apr 2025 07:00:00 GMT

최종 파이썬 코드 구성

아래의 파이썬 코드는 이전 글에서 작성한 파일 단위로 저장된 XML을 처리하고 결과를 CSV로 정리하는 파이썬 스크립트에서 url을 받도록 구성된 것이며, 대부분의 중요한 기능은 동일하다.

Google News RSS feedparser [펼치기/접기]

# feedparser는 url을 바로 입력해도 처리함.
# 시간변환함수 추가, 
# 파일로 저장 기능 추가
# 사용방법: python google_feed_parser_url.py {search_term} {} output_path

import os
import sys
import urllib.parse
import feedparser
from datetime import datetime, timezone, timedelta # 날짜 형식 변환
from email.utils import parsedate_to_datetime # 날짜 형식 변환
import csv # 파일로 저장 기능 추가

# 한국 시간대 (UTC+9)
KST = timezone(timedelta(hours=9))

# 날짜 형식 변환 함수 - 한국 시간으로 변환
def format_date_to_kst(date_str):
    try:
        # RSS 날짜 형식(RFC 822)을 파싱
        dt = parsedate_to_datetime(date_str)
        # UTC에서 KST로 변환
        dt_kst = dt.astimezone(KST)
        # 연도, 월, 날짜, 시간(24시간) 형식으로 변환
        return dt_kst.strftime('%Y-%m-%d %H:%M:%S')
    except Exception:
        try:
            # ISO 8601 형식 시도
            dt = datetime.fromisoformat(date_str.replace('Z', '+00:00'))
            # UTC에서 KST로 변환
            dt_kst = dt.astimezone(KST)
            return dt_kst.strftime('%Y-%m-%d %H:%M:%S')
        except:
            # 변환 실패 시 원본 반환
            return date_str

def get_rss_url(search_term):
    # search_term을 그대로 인코딩 (이미 날짜 범위 등 포함)
    encoded_search_term = urllib.parse.quote(search_term)
    rss_url = f'https://news.google.com/rss/search?q={encoded_search_term}&hl=ko&gl=KR&ceid=KR%3Ako'
    return rss_url

def main():
    # 명령줄 인자 처리
    if len(sys.argv) != 3:
        print("사용방법: python foo.py \"search_term\" output_path")
        print("예시: python foo.py \"\\\"포스코\\\" after:2025-05-15 before:2025-05-17\" output.csv")
        sys.exit(1)
    
    # 명령줄에서 인자 받기
    search_term = sys.argv[1]
    output_path = sys.argv[2]
    
    # RSS 피드 URL 생성 (Google News는 검색결과를 RSS로도 제공)
    rss_url = get_rss_url(search_term)
    print(f"검색어: {search_term}")
    print(f"RSS URL: {rss_url}")
    
    # RSS 피드 파싱
    print("\nRSS 피드 파싱 중...")
    feed = feedparser.parse(rss_url)
    
    # CSV 파일로 데이터 저장
    with open(output_path, 'w', newline='', encoding='utf-8') as csvfile:
        # CSV 작성자 생성
        csv_writer = csv.writer(csvfile)       
        # 헤더 작성
        csv_writer.writerow(['pubtime', 'title', 'link'])
        
        # 모든 기사 출력 (요약 없음)
        print("\n모든 기사:")
        for i, entry in enumerate(feed.entries, 1):           
            title = entry.title if hasattr(entry, 'title') else "제목 없음"
            link = entry.link if hasattr(entry, 'link') else "링크 없음"        
            published = format_date_to_kst(entry.published) if hasattr(entry, 'published') else "발행일 없음"
                 
            # CSV 파일에 데이터 저장
            csv_writer.writerow([published, title, link])
    
    print(f"CSV 파일이 성공적으로 저장되었습니다: {output_path}")
    print(f"총 {len(feed.entries)}개 항목이 저장되었습니다.")

if __name__ == "__main__":
    main()

파이썬 코드 실행 결과 예시

파일을 열어보면, 모든 정보가 잘 저장되어 있다.

Power Automate와 연동한 자동 실행

이제 마지막으로, 파이썬 스크립트를 Powerautomate와 연동해 자동화를 하면 다음과 같은 결과를 얻을 수 있다. Power Automate는 스크립트를 작성하고, 실행하는 역할을 하고 실제 기능은 파이썬에서 구동된다.한가지, 아쉬운 점은 Power Automate는 변수 하나에 한줄을 사용해야 해서 간단한 변수를 설정하는데도 흐름이 길어진다.

Power Automate 최종 흐름

마치며

이번 글에서는 feedparser와 urllib.parse를 활용해, 구글 뉴스 rss에서 기사 제목과 링크, 발행일을 웹에서 직접 추출하여 시간을 단축하는 방법을 살펴보았다. 다음 글에서는 수집한 Google 뉴스 주소를 원문 URL로 변환하는 방법을 소개하고자 한다.

Power Automate와 Python을 활용한 주도주 재료 분석 자동화 - 1

catalystmind — Wed, 14 May 2025 20:22:32 +0900

TL;DR

Google RSS XML, 기본 XML 구조 따르며 컴퓨터 폴더 구조와 유사한 계층적 특성
feedparser, 폴더 구조 같은 XML 파일을 간단한 명령어로 쉽게 처리 가능
최종 Python 코드는 XML 파일 처리 후 CSV로 정리
해당 코드, 단독 실행 가능 및 Power Automate와 연동 통한 자동화 흐름 일부로 활용 가능
Power Automate만으로 5분 걸리던 작업, feedparser 활용 시 단 3초 만에 처리

앞에서 소개한 Power Automate를 활용한 방식은 저장된 xml 파일 10개 처리에만 약 5분가량이 소요되었다. 이 단계의 처리 시간 개선을 위해 사용법이 간단하면서도 강력한 기능을 제공하는 파이썬 라이브러리 feedparser를 도입하였다.

XML은 폴더 구조와 같은 계층적 특성을 가진다.

구글 RSS은 엄격한 XML 문법을 따르지는 않지만 기본적인 XML 구조를 따른다. XML은 컴퓨터의 폴더 구조와 매우 유사한 다음과 같은 계층적 구조를 가진다. (폴더 아이콘을 클릭하면 펼쳐짐)

RSS 피드 XML 구조 (폴더형 시각화)

<rss> - RSS 루트 요소 (버전, 네임스페이스 정보 포함)

<channel> - 피드 메타데이터와 뉴스 아이템 컨테이너

<title> - 피드 제목 ("KTis after:2025-05-01 before:2025-05-03" - Google 뉴스)

<language> - 언어 (ko)

<webMaster> - 웹마스터 정보 (news-webmaster@google.com)

<lastBuildDate> - 마지막 업데이트 날짜 (Sat, 03 May 2025 11:23:03 GMT)

<image> - 피드 이미지 정보

<title> - 이미지 제목

<url> - 이미지 URL

<height> - 이미지 높이

<width> - 이미지 너비

<description> - 피드 설명 (Google 뉴스)

<item> - 첫 번째 뉴스 기사

<title> - 뉴스 제목 ([특징주] KTis, SKT 사태 해결까지 신규 모집중단…)

<guid> - 고유 식별자 (각 뉴스 항목의 영구적인 고유 ID로 중복 방지와 추적에 사용)

<pubDate> - 발행일 (Fri, 02 May 2025 00:45:14 GMT)

<description> - 설명 (HTML 포함)

<source> - 출처 (머니S)

<item> - 두 번째 뉴스 기사

<title> - 뉴스 제목 (KTis, +18.98% 52주 신고가)

<guid> - 고유 식별자 (각 뉴스 항목의 영구적인 고유 ID로 중복 방지와 추적에 사용)

<pubDate> - 발행일 (Fri, 02 May 2025 04:17:00 GMT)

<description> - 설명 (HTML 포함)

<source> - 출처 (Chosunbiz)

<item> - 추가 뉴스 기사들...

Feedparser: 폴더처럼 생긴 XML을 쉽게 다루는 도구

feedparser의 주요 기능

기능	설명
다양한 피드 형식 지원	대부분의 RSS 2.0, Atom 1.0 등 표준 피드를 지원
간편한 사용법	복잡한 XML을 Python의 딕셔너리 및 리스트 형태로 자동 변환
자동 인코딩 감지	UTF-8, ISO-8859 등 다양한 문자 인코딩을 자동 인식
날짜 형식 자동 처리	다양한 피드의 날짜 표현을 Python datetime 형식으로 변환
순수 Python 구현	별도의 의존성 없이 설치와 실행이 간단

feedparser 사용 예시

Python feedparser 라이브러리를 사용하여 이 XML 구조의 데이터를 추출하는 기본 코드 예시:

import feedparser
# XML 파일 파싱
feed = feedparser.parse("2025-05-02_KTis.xml")
# 피드 메타데이터 접근
feed_title = feed.feed.title
feed_link = feed.feed.link
feed_language = feed.feed.language
last_build_date = feed.feed.lastbuilddate
# 뉴스 기사 접근
for entry in feed.entries:
    title = entry.title
    link = entry.link
    published = entry.published
    source = entry.source.title if hasattr(entry, 'source') else ''
    
    print(f"제목: {title}")
    print(f"출처: {source}")
    print(f"발행일: {published}")
    print(f"링크: {link}")
    print("-------------------")

최종 파이썬 코드 구성

입력 폴더 처리: 지정된 폴더 내에 있는 모든 *.xml 파일들을 순회하면서 하나씩 읽고 처리. 명령줄 인자로 경로를 입력받아, Powerautomate 자동화 흐름에 쉽게 통합 가능.

Feedparser를 활용한 XML 구조 해석: XML 파일을 feedparser로 읽고, 내부에 있는 각 뉴스 항목의 제목, 링크, 발행일 등을 추출. 복잡한 XML 트리를 Powerautomate의 정규식을 이용해서 직접 다룰 필요 없음.

시간 정보 처리 (UTC → KST 변환): RSS 피드는 발행 시간을 한국 표준시(KST, UTC+9)로 변환.

CSV 저장: 각 XML 파일에 대해 [파일명]_google_url.csv 형태로 결과를 저장. 다음 작업 연계를 위해, 저장되는 항목은 발행일, 제목, 링크로 구성됨.

디버깅을 위한 출력 처리: 처리 완료된 파일 수와 항목 수를 요약 출력, 스크립트가 정상 실행되었는지 확인 가능.

아래의 최종 코드는 실제 파일 단위로 저장된 XML을 처리하고 결과를 CSV로 정리하는 파이썬 스크립트다. 단독으로 실행할 수 있을 뿐만 아니라, Powerautomate와 연동해 자동화 흐름의 일부로 동작시킬 수 있다. 주요 구성은 다음과 같다:

google_feed_parser.py [펼치기/접기]

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
구글 뉴스 XML/RSS/TXT 피드 파서
다양한 형식의 구글 뉴스 피드 파일을 CSV 파일로 변환합니다.

사용법: python google_feed_parser.py [입력_폴더] [출력_폴더]
출력 폴더를 지정하지 않으면 입력 폴더와 동일한 위치에 저장됩니다.
예시: python google_feed_parser.py xml_files
      python google_feed_parser.py xml_files csv_files
"""

import feedparser
import os
import csv
import sys
from datetime import datetime, timezone, timedelta
from email.utils import parsedate_to_datetime

def main():
    # 명령줄 인수 처리
    if len(sys.argv) >= 2:
        input_folder = sys.argv[1]
        # 출력 폴더가 지정되지 않은 경우 입력 폴더와 동일하게 설정
        output_folder = sys.argv[2] if len(sys.argv) >= 3 else input_folder
    else:
        print("사용법: python google_feed_parser.py [입력_폴더] [출력_폴더]")
        print("출력 폴더를 지정하지 않으면 입력 폴더와 동일한 위치에 저장됩니다.")
        print("예시: python google_feed_parser.py xml_files")
        print("      python google_feed_parser.py xml_files csv_files")
        sys.exit(1)
    
    # 입력 폴더 확인
    if not os.path.exists(input_folder):
        print(f"오류: 입력 폴더를 찾을 수 없습니다: {input_folder}")
        sys.exit(1)
    
    if not os.path.isdir(input_folder):
        print(f"오류: 입력 경로가 폴더가 아닙니다: {input_folder}")
        sys.exit(1)
    
    # 출력 폴더가 입력 폴더와 다른 경우에만 생성
    if output_folder != input_folder and not os.path.exists(output_folder):
        try:
            os.makedirs(output_folder)
            print(f"출력 폴더를 생성했습니다: {output_folder}")
        except Exception as e:
            print(f"오류: 출력 폴더를 생성할 수 없습니다: {output_folder} - {str(e)}")
            sys.exit(1)
    
    # 파일 처리 시작
    process_folder(input_folder, output_folder)

def process_folder(input_folder, output_folder):
    """지정된 폴더의 모든 피드 파일을 처리합니다."""
    
    # 한국 시간대 (UTC+9)
    KST = timezone(timedelta(hours=9))
    
    # 처리 결과 카운터
    successful_files = 0
    failed_files = 0
    skipped_files = 0
    total_entries = 0
    
    # 지원되는 확장자 목록 (txt 포함)
    supported_extensions = ['.xml', '.rss', '.atom', '.feed', '.txt']
    
    print(f"폴더 '{input_folder}'에서 피드 파일 검색 중...")
    
    # 폴더 내 모든 파일 나열
    all_files = os.listdir(input_folder)
    print(f"총 {len(all_files)}개 파일 발견")
    
    # 폴더 내 모든 파일 처리
    for filename in all_files:
        file_path = os.path.join(input_folder, filename)
        
        # 파일인지 확인
        if os.path.isfile(file_path):
            # 파일 확장자 확인
            _, ext = os.path.splitext(filename)
            
            print(f"파일 검사 중: {filename} (확장자: {ext})")
            
            # 지원되는 확장자인 경우
            if ext.lower() in supported_extensions:
                print(f"지원되는 확장자: {ext} - 처리 시도")
                
                # 피드 파일 처리
                if process_feed_file(file_path, output_folder, KST):
                    successful_files += 1
                    # 항목 수 추가
                    feed = feedparser.parse(file_path)
                    total_entries += len(feed.entries)
                else:
                    failed_files += 1
            else:
                # 지원되지 않는 확장자지만 유효한 피드인지 확인
                print(f"지원되지 않는 확장자: {ext} - 유효성 확인 중")
                if is_valid_feed(file_path):
                    print(f"유효한 피드로 확인됨: {filename} - 처리 시도")
                    if process_feed_file(file_path, output_folder, KST):
                        successful_files += 1
                        feed = feedparser.parse(file_path)
                        total_entries += len(feed.entries)
                    else:
                        failed_files += 1
                else:
                    skipped_files += 1
                    print(f"건너뜀: {filename} (지원되지 않는 파일 형식)")
    
    # 결과 요약 출력
    print("\n===== 처리 결과 =====")
    print(f"처리된 피드 파일: {successful_files}개")
    print(f"실패한 피드 파일: {failed_files}개")
    print(f"건너뛴 파일: {skipped_files}개")
    print(f"처리된 총 항목 수: {total_entries}개")
    print(f"CSV 파일 저장 위치: {output_folder}")
    print("모든 시간은 한국 시간(KST, UTC+9) 기준으로 변환되었습니다.")
    print("모든 CSV 파일은 '[원본파일명]_google_url.csv' 형식으로 저장되었습니다.")
    print(f"지원되는 파일 확장자: {', '.join(supported_extensions)}")

def format_date_to_kst(date_str, KST):
    """날짜 문자열을 한국 시간으로 변환합니다."""
    try:
        # RSS 날짜 형식(RFC 822)을 파싱
        dt = parsedate_to_datetime(date_str)
        # UTC에서 KST로 변환
        dt_kst = dt.astimezone(KST)
        # 연도, 월, 날짜, 시간(24시간) 형식으로 변환
        return dt_kst.strftime('%Y-%m-%d %H:%M:%S')
    except Exception:
        try:
            # ISO 8601 형식 시도
            dt = datetime.fromisoformat(date_str.replace('Z', '+00:00'))
            # UTC에서 KST로 변환
            dt_kst = dt.astimezone(KST)
            return dt_kst.strftime('%Y-%m-%d %H:%M:%S')
        except:
            # 변환 실패 시 원본 반환
            return date_str

def is_valid_feed(file_path):
    """파일이 유효한 피드인지 확인합니다."""
    try:
        # 파일 내용 읽기 (디버깅 출력)
        try:
            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
                content = f.read(1000)  # 처음 1000자만 읽기
                print(f"파일 확인: {file_path}")
                print(f"파일 미리보기: {content[:100]}...")  # 처음 100자 출력
        except Exception as e:
            print(f"파일 읽기 오류: {file_path} - {str(e)}")
        
        # 피드 파싱 시도
        feed = feedparser.parse(file_path)
        
        # 디버깅 출력
        print(f"파싱 결과: version={feed.get('version', 'None')}, entries={len(feed.get('entries', []))}")
        
        # 피드에 entries가 있으면 유효한 피드로 간주
        return hasattr(feed, 'entries') and len(feed.entries) > 0
    except Exception as e:
        print(f"파일 유효성 확인 오류: {file_path} - {str(e)}")
        return False

def process_feed_file(feed_file_path, output_folder, KST):
    """피드 파일을 처리하여 CSV 파일로 저장합니다."""
    # 출력 CSV 파일 경로 생성 (피드 파일명 + google_url)
    base_filename = os.path.splitext(os.path.basename(feed_file_path))[0]
    csv_file_path = os.path.join(output_folder, base_filename + "_google_url.csv")
    
    try:
        # 피드 파일 파싱
        feed = feedparser.parse(feed_file_path)
        
        # 피드 기본 정보 (디버깅)
        if hasattr(feed, 'feed') and hasattr(feed.feed, 'title'):
            print(f"피드 제목: {feed.feed.title}")
        
        # 항목이 없으면 건너뛰기
        if not hasattr(feed, 'entries') or len(feed.entries) == 0:
            print(f"건너뜀: {feed_file_path} 파일에 유효한 피드 항목이 없습니다.")
            return False
            
        # CSV 파일로 데이터 저장
        with open(csv_file_path, 'w', newline='', encoding='utf-8') as csvfile:
            # CSV 작성자 생성
            csv_writer = csv.writer(csvfile)
            
            # 헤더 작성
            csv_writer.writerow(['발행일(KST)', '제목', '링크'])
            
            # 각 항목(기사) 정보를 CSV에 저장
            for entry in feed.entries:
                title = entry.title if hasattr(entry, 'title') else "제목 없음"
                link = entry.link if hasattr(entry, 'link') else "링크 없음"
                
                # 발행일 형식 변환 (KST 적용)
                if hasattr(entry, 'published'):
                    published = format_date_to_kst(entry.published, KST)
                else:
                    published = "발행일 없음"
                
                # CSV 파일에 데이터 저장
                csv_writer.writerow([published, title, link])
        
        print(f"처리 완료: {feed_file_path} -> {csv_file_path} (항목 {len(feed.entries)}개)")
        return True
    
    except Exception as e:
        print(f"오류 발생: {feed_file_path} 처리 중 - {str(e)}")
        return False

# 메인 함수 실행
if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\n사용자에 의해 프로그램이 중단되었습니다.")
        sys.exit(0)
    except Exception as e:
        print(f"\n예상치 못한 오류가 발생했습니다: {str(e)}")
        sys.exit(1)

파이썬 코드 실행 결과 예시

Power Automate와 연동한 자동 실행

아래의 흐름에 파이썬 스크립트를 Powerautomate와 연동해 자동화를 진행한 예시다. Powerautomate만 사용하면 약 5분이 걸리는 작업을 단 3초만에 끝낼 수 있다.

마치며

이번 글에서는 feedparser를 활용해 구글 뉴스 RSS에서 가져온 XML 파일을 정리하고, 기사 제목과 링크, 발행일을 빠르게 추출하는 방법을 살펴보았다. 다음 글에서는 Google 뉴스 주소를 원문 URL로 변환하는 방법을 소개하고자 한다.

Power Automate와 Python을 활용한 주도주 재료 분석 자동화 - 서론

catalystmind — Tue, 13 May 2025 21:52:32 +0900

TL;DR

Power Automate만 사용한 기존 방식은 속도 제한(90분+), 높은 비용, 유지보수 어려움이라는 한계에 직면
해결책으로 Power Automate와 Python 연동 방식 제안 (Jupyter로 작성, PowerShell로 실행)
주요 도구: feedparser, googlenewsdecoder, trafilatura를 활용한 뉴스 수집 및 정제 자동화

Power automate를 활용한 기존 방식의 개선 필요성

매일 한 종목과 관련된 기사만 해도 종목당 평균 30개 정도가 발생한다. 관심 있는 종목이 10개만 되어도 하루에 300개의 기사가 쏟아지는 셈이다. 이 기사들이 모두 의미가 있는 것은 아니지만 그 중에 의미있는 기사를 가려내고 읽는 것만으로도 전업 투자자가 아닌 직장인이 일일이 읽고 분석하는 것은 사실상 불가능하다.

앞의 글에서 Microsoft Power Automate 같은 기존 도구로는 자동화를 시도해 보았지만, 자동화는 가능하지만 시간이 너무 많이 소요된다는 문제가 발생했다.

이 문제를 해결하기 위해 여러 가지 접근을 시도해 왔고, 그중 가장 실용적이고 효율적이었던 방법을 Power automate와 파이썬조합으로 찾았다. 이 글은 앞으로 이어질 파이썬을 활용한 뉴스 자동화 시리즈의 첫 번째로, 재료 분석 자동화에 필요한 절처화 도구를 소개하고자 한다.

기존 방식의 한계

초기에는 Microsoft Power Automate를 기반으로 뉴스 기사를 수집하고, GPT를 활용해 본문을 정제하는 워크플로우를 구성했다. 하지만, 다음과 같은 문제에 곧 직면하게 되었다:

처리 속도 문제
- 브라우저 기반 자동화는 기사 300개를 처리하는 데 약 90분 이상 소요
- 퇴근 후 데이터 수집을 시작하면 분석할 시간 자체가 부족
정제 비용 증가
- 광고, 댓글, 관련 기사 링크 등이 함께 수집
- GPT를 통한 후처리에 불필요한 토큰 비용 낭비
유지보수 어려움
- 언론사마다 HTML 구조가 다르고 본문의 위치가 다름

주요 파이썬 패키지

단계	작업 내용	파이썬 패키지
1	KRX 거래소에서 당일 거래량 상위 10개 종목 추출	Power Automate
2	종목별 구글 뉴스 RSS(XML) 수집	feedparser
3	XML 정제 후 뉴스 URL 추출	googlenewsdecoder
4	뉴스 URL로부터 원문 기사 내용 수집	Trafilatura

Power Automate는 파이썬을 지원하지만 문제가 있다

Power Automate는 파이썬 스크립트를 바로 작성해서 실행할 수 있다. 하지만, Power Automate가 지원하는 파이썬 버전이 3.4로 제한되어 있어 pandas와 같은 필수 package를 사용할 수 없다. pandas의 요구사항은 Python >=3.9

이 제약사항을 해결하기 위한 방안은 아래와 같다.

Jupyter Notebook에서 파이썬 스크립트 작성
PowerShell로 외부 Python 실행 자동화

앞으로 다룰 내용

다음 글들에서는 아래 주제들을 구체적으로 다룰 예정이다:

feedparser - XML에서 구글 url 및 메타 데이터 (발행일시, 기사 제목 등) 추출
googlenewsdecoder - 구글 뉴스 url을 실제 언론 기사 url로 변환
Trafilatura - 기사 본문 추출

마치며

시간이 부족한 직장인은 제한된 시간 내에서 효율적인 정보 수집과 분석이 요구되며, 이를 위한 자동화는 필수적이다. 다음 글에서는 feedparser를 활용해 구글 뉴스 RSS에서 원하는 기사를 자동 수집하는 방법을 실전 예시와 함께 소개한다.