kci_full_download.py

import requests
import xml.etree.ElementTree as ET
import time
import os
import json
import sys

class KCIKciHarvester:
    def __init__(self, save_dir=r"D:\KCI\data_kci_format"):
        self.base_url = "https://open.kci.go.kr/oai/request"
        self.save_dir = save_dir
        self.state_file = os.path.join(save_dir, "harvest_state_v2.json")
        
        # 저장 폴더 생성 (폴더명을 바꿔 섞이지 않게 함)
        os.makedirs(self.save_dir, exist_ok=True)
        self.state = self.load_state()

    def load_state(self):
        if os.path.exists(self.state_file):
            try:
                with open(self.state_file, 'r', encoding='utf-8') as f:
                    return json.load(f)
            except:
                pass
        return {"last_token": None, "page_count": 1}

    def save_state(self, token, page_count):
        self.state = {"last_token": token, "page_count": page_count}
        with open(self.state_file, 'w', encoding='utf-8') as f:
            json.dump(self.state, f, indent=4)

    def verify_xml(self, filepath):
        try:
            tree = ET.parse(filepath)
            root = tree.getroot()
            ns = {'oai': 'http://www.openarchives.org/OAI/2.0/'}
            
            error = root.find('.//oai:error', ns)
            if error is not None:
                print(f"⚠️ API Error: {error.text}")
                return 0
            
            # 레코드 수 확인
            records = root.findall('.//oai:record', ns)
            return len(records)
        except Exception:
            return -1

    def run(self):
        print("="*60)
        print(f"   KCI 고품질 데이터(oai_kci) 수집기")
        print(f"   저장 경로: {self.save_dir}")
        print("="*60)
        
        token = self.state["last_token"]
        page = self.state["page_count"]
        
        if token:
            print(f"🔄 {page}페이지부터 이어받습니다...")
            params = {'verb': 'ListRecords', 'resumptionToken': token}
        else:
            print(f"▶️ 처음부터 시작 (Format: oai_kci, Set: ARTI)")
            params = {
                'verb': 'ListRecords',
                'set': 'ARTI',       # 학술지 논문 대상
                'metadataPrefix': 'oai_kci' # ✅ 핵심 변경: 구조화된 데이터 요청
            }

        consecutive_errors = 0

        while True:
            try:
                sys.stdout.write(f"\r📥 Page {page} (oai_kci) 다운로드 중... ")
                sys.stdout.flush()
                
                response = requests.get(self.base_url, params=params, timeout=60)
                
                if response.status_code != 200:
                    print(f"\n⛔ 서버 에러({response.status_code})...")
                    time.sleep(10)
                    consecutive_errors += 1
                    if consecutive_errors > 5: break
                    continue

                # 파일 저장
                filename = os.path.join(self.save_dir, f"kci_detailed_{page:06d}.xml")
                with open(filename, "w", encoding="utf-8") as f:
                    f.write(response.text)

                count = self.verify_xml(filename)
                if count == -1:
                    print(f"\n⚠️ 파일 손상. 재시도.")
                    time.sleep(3)
                    continue
                
                sys.stdout.write(f"✅ 완료 ({count}건)\n")

                # 토큰 추출
                root = ET.fromstring(response.text)
                ns = {'oai': 'http://www.openarchives.org/OAI/2.0/'}
                token_elem = root.find('.//oai:resumptionToken', ns)

                if token_elem is not None and token_elem.text:
                    new_token = token_elem.text
                    page += 1
                    self.save_state(new_token, page)
                    
                    # 토큰만으로 요청 (파라미터 초기화)
                    params = {'verb': 'ListRecords', 'resumptionToken': new_token}
                    consecutive_errors = 0
                    time.sleep(0.5)
                else:
                    print(f"\n🏁 수집 완료!")
                    break

            except KeyboardInterrupt:
                print("\n⏹️ 중단됨.")
                break
            except Exception as e:
                print(f"\n❌ 에러: {e}")
                time.sleep(10)

if __name__ == "__main__":
    harvester = KCIKciHarvester()
    harvester.run()