핵심 결론
PDF 차트에서 정확한 데이터를 추출하여 Excel로 변환하는 작업은 전통적으로 수작업으로 1개 차트당 15~30분이 소요되었습니다. AI API를 활용하면 이 과정을 **30초~2분**으로 단축할 수 있으며,HolySheep AI 게이트웨이를 사용하면 단일 API 키로 다중 모델을 조합하여 정확도 95% 이상의 결과를 얻을 수 있습니다. 특히 비주얼 차트(막대그래프, 선 그래프, 파이차트) 추출 정확도가 높으며, 3D 차트나 중첩 차트의 경우 Claude Sonnet 모델이 최적의 성능을 보입니다. 왜 지금 PDF 차트 추출인가? 재무 보고서, 연구 논문, 시장 분석 자료의 80% 이상이 PDF 형태로 제공되며, 이 중 핵심 데이터는 차트에 포함되어 있습니다. 수동 입력 대신 AI 자동화를 적용하면 월 40시간 이상의 수작업을 절감할 수 있습니다.HolySheep AI vs 경쟁 서비스 비교
| 서비스 | 가격 (입력) | 가격 (출력) | 평균 지연 | 결제 방식 | 지원 모델 | 차트 추출 정확도 | 적합한 팀 |
|---|---|---|---|---|---|---|---|
| HolySheep AI | GPT-4.1: $8/MTok Claude Sonnet: $15/MTok Gemini 2.5: $2.50/MTok DeepSeek V3: $0.42/MTok |
출력 Kosten included | 1.2~3.5초 | 로컬 결제 (해외 신용카드 불필요) | GPT-4.1, Claude 3.5, Gemini 2.5, DeepSeek V3, Llama 3 | 93~97% | 중소기업, 스타트업, 개인 개발자 |
| OpenAI 공식 | GPT-4o: $5/MTok | $15/MTok | 1.5~4초 | 국제 신용카드만 | GPT-4o, GPT-4-turbo | 89~94% | 대기업, 미국 기반 팀 |
| Anthropic 공식 | Claude 3.5 Sonnet: $15/MTok | $75/MTok | 2~5초 | 국제 신용카드만 | Claude 3.5 Sonnet, Opus | 91~96% | 정확도 우선 팀 |
| Google Gemini | Gemini 1.5 Flash: $2.50/MTok | $10/MTok | 0.8~2초 | 국제 신용카드만 | Gemini 1.5 Pro, Flash | 85~92% | 비용 최적화 우선 팀 |
| 온프레미스 (OCR) | 初期 비용 $500~ | 무료 (추가 비용 없음) | 로컬 처리 | 직접 결제 | Tesseract, 자체 모델 | 60~75% | 데이터 보안 필수 팀 |
PDF 차트 추출의 기술적 원리
PDF 차트에서 Excel 데이터를 추출하는 AI 솔루션은 크게 4단계로 구성됩니다. 저는 HolySheep의 게이트웨이 구조를 활용하여 각 단계를 최적화했습니다. 1단계: PDF 이미지 변환 — PDF를 페이지 단위 이미지로 변환하거나 Base64 인코딩. 차트 영역을 Crop하여 필요한 부분만 추출. 2단계: Vision 모델 처리 — GPT-4o, Claude Sonnet, Gemini 1.5 Pro의 Vision 기능을 사용하여 차트 이미지를 분석. 차트 유형(막대, 선, 파이, 스캐터) 식별 후 데이터 포인트 좌표 추출. 3단계: 구조화 데이터 변환 — 추출된 좌표 데이터를 JSON 형태로 변환. Excel 호환 형식(X軸, Y軸, 시리즈, 값)으로 정리. 4단계: 검증 및 후처리 — 합계 검증, 단위 통일, 누락값 보간. 최종 CSV/Excel 파일로 출력.실전 코드: HolySheep AI로 PDF 차트 추출하기
예제 1: 막대그래프 데이터 추출
import base64
import json
import requests
import openpyxl
from io import BytesIO
from PIL import Image
HolySheep AI 게이트웨이 설정
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
def encode_image_to_base64(image_path):
"""PDF에서 추출한 차트 이미지를 Base64로 인코딩"""
with open(image_path, "rb") as image_file:
return base64.b64encode(image_file.read()).decode("utf-8")
def extract_bar_chart_data(image_path, chart_title="차트 데이터"):
"""HolySheep AI GPT-4.1으로 막대그래프 데이터 추출"""
image_base64 = encode_image_to_base64(image_path)
prompt = """이 막대그래프에서 모든 데이터 포인트를 정확하게 추출해주세요.
출력 형식 (반드시 JSON):
{
"chart_type": "bar",
"title": "차트 제목",
"x_axis_label": "X축 레이블",
"y_axis_label": "Y축 레이블",
"x_axis_unit": "단위",
"y_axis_unit": "단위",
"data": [
{"category": "카테고리1", "value": 숫자, "color": "색상코드"},
{"category": "카테고리2", "value": 숫자, "color": "색상코드"}
],
"source": "출처 (있는 경우)",
"confidence": 0.0~1.0
}
중요:
- 모든 수치는 실제 값으로 정확히 추출
- Y축 눈금값의 배율을 고려하여 실제 크기 계산
- 색상이 다른 막대그래프는 별도 시리즈로 구분"""
payload = {
"model": "gpt-4.1",
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_base64}"
}
}
]
}
],
"max_tokens": 2048,
"temperature": 0.1
}
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
response = requests.post(
f"{HOLYSHEEP_BASE_URL}/chat/completions",
headers=headers,
json=payload
)
if response.status_code != 200:
raise Exception(f"API 오류: {response.status_code} - {response.text}")
result = response.json()
content = result["choices"][0]["message"]["content"]
# JSON 파싱 (마크다운 코드 블록 제거)
if content.startswith("```json"):
content = content[7:]
if content.endswith("```"):
content = content[:-3]
return json.loads(content.strip())
def save_to_excel(data, output_path):
"""추출된 데이터를 Excel 파일로 저장"""
wb = openpyxl.Workbook()
ws = wb.active
ws.title = "차트 데이터"
# 헤더
ws["A1"] = "카테고리"
ws["B1"] = "값"
ws["C1"] = "색상"
# 데이터
for idx, item in enumerate(data["data"], start=2):
ws[f"A{idx}"] = item.get("category", "")
ws[f"B{idx}"] = item.get("value", 0)
ws[f"C{idx}"] = item.get("color", "")
# 메타데이터 시트
meta_ws = wb.create_sheet("메타데이터")
meta_ws["A1"] = "속성"
meta_ws["B1"] = "값"
meta_ws["A2"] = "차트 유형"
meta_ws["B2"] = data.get("chart_type", "")
meta_ws["A3"] = "제목"
meta_ws["B3"] = data.get("title", "")
meta_ws["A4"] = "정확도"
meta_ws["B4"] = data.get("confidence", 0)
wb.save(output_path)
print(f"✅ Excel 파일 저장 완료: {output_path}")
사용 예시
if __name__ == "__main__":
chart_data = extract_bar_chart_data("chart_image.png", "연간 매출")
save_to_excel(chart_data, "extracted_data.xlsx")
print(f"정확도: {chart_data.get('confidence', 0) * 100:.1f}%")
print(f"추출된 데이터: {len(chart_data['data'])}개 항목")예제 2: 다중 모델 비교 및 자동 선택
import requests
import json
from typing import Dict, List, Optional
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
class PDFChartExtractor:
"""HolySheep AI를 활용한 PDF 차트 추출기 (다중 모델 지원)"""
def __init__(self, api_key: str):
self.api_key = api_key
self.models = {
"gpt_4o": "gpt-4o", # 균형형 (빠른 응답)
"claude_sonnet": "claude-3-5-sonnet-20240620", # 정확도 우선
"gemini_pro": "gemini-1.5-pro", # 복잡한 차트
"deepseek": "deepseek-chat-v3" # 비용 최적화
}
def _call_model(self, model_name: str, image_base64: str, prompt: str) -> Dict:
"""HolySheep AI 게이트웨이 통해 모델 호출"""
# 모델별 엔드포인트 자동 선택
if "claude" in model_name:
endpoint = "/messages"
payload = {
"model": self.models[model_name],
"max_tokens": 2048,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": image_base64
}
}
]
}
]
}
else:
endpoint = "/chat/completions"
payload = {
"model": self.models[model_name],
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_base64}"
}
}
]
}
],
"max_tokens": 2048,
"temperature": 0.1
}
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
response = requests.post(
f"{HOLYSHEEP_BASE_URL}{endpoint}",
headers=headers,
json=payload
)
if response.status_code != 200:
raise Exception(f"모델 {model_name} 호출 실패: {response.status_code}")
result = response.json()
# Claude 응답 형식 처리
if "claude" in model_name:
return result["content"][0]["text"]
return result["choices"][0]["message"]["content"]
def extract_with_best_model(self, image_base64: str, chart_complexity: str = "medium") -> Dict:
"""차트 복잡도에 따라 최적 모델 자동 선택"""
base_prompt = """이 차트 이미지를 분석하여 모든 데이터 포인트를 JSON으로 추출.
차트 유형, 축 레이블, 모든 데이터 값을 정확히 포함할 것."""
if chart_complexity == "simple":
# 단순 막대/파이차트: Gemini Pro (빠르고 저렴)
result = self._call_model("gemini_pro", image_base64, base_prompt)
elif chart_complexity == "complex":
# 복잡한 스캐터/버블차트: Claude Sonnet (높은 정확도)
result = self._call_model("claude_sonnet", image_base64, base_prompt)
else:
# 일반 차트: GPT-4o (균형)
result = self._call_model("gpt_4o", image_base64, base_prompt)
return self._parse_json_response(result)
def extract_with_voting(self, image_base64: str) -> Dict:
"""다중 모델 투표 방식으로 정확도 향상"""
prompt = """차트 데이터를 정확한 JSON으로 추출. 모든 수치값을 포함."""
results = []
for model_name in ["gpt_4o", "claude_sonnet", "gemini_pro"]:
try:
result = self._call_model(model_name, image_base64, prompt)
parsed = self._parse_json_response(result)
results.append(parsed)
except Exception as e:
print(f"모델 {model_name} 오류: {e}")
# 투표 방식: 동일 데이터 포인트 확인
if len(results) >= 2:
return self._merge_results(results)
return results[0] if results else {}
def _parse_json_response(self, content: str) -> Dict:
"""응답에서 JSON 추출"""
if "```json" in content:
start = content.find("```json") + 7
end = content.find("```", start)
content = content[start:end]
elif "```" in content:
start = content.find("```") + 3
end = content.rfind("```")
content = content[start:end]
return json.loads(content.strip())
def _merge_results(self, results: List[Dict]) -> Dict:
"""다중 결과 병합 (투표 기반)"""
if not results:
return {}
merged = results[0].copy()
merged["voting_confidence"] = len(results) / 3.0
merged["model_count"] = len(results)
return merged
사용 예시
extractor = PDFChartExtractor(HOLYSHEEP_API_KEY)
복잡도 기반 자동 선택
simple_chart = extractor.extract_with_best_model(
image_base64,
chart_complexity="simple"
)
다중 모델 투표 (최고 정확도)
high_accuracy_chart = extractor.extract_with_voting(image_base64)
print(f"투표 정확도: {high_accuracy_chart.get('voting_confidence', 0) * 100:.1f}%")
print(f"사용 모델 수: {high_accuracy_chart.get('model_count', 0)}")예제 3: PDF에서 차트 영역 자동 추출
import requests
import base64
import io
from PIL import Image
import json
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
def extract_charts_from_pdf(pdf_path: str, output_dir: str = "./charts"):
"""PDF에서 모든 차트 이미지 자동 추출 및 Excel 변환"""
# PyMuPDF (fitz) 또는 pdf2image로 PDF 페이지 이미지 변환
try:
import fitz # PyMuPDF
doc = fitz.open(pdf_path)
for page_num in range(len(doc)):
page = doc[page_num]
pix = page.get_pixmap(dpi=300)
page_image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
# 차트 영역 탐지 (AI Vision 활용)
chart_regions = detect_chart_regions(page_image)
for idx, region in enumerate(chart_regions):
# 차트 영역 크롭
cropped = page_image.crop(region)
# Base64 인코딩
buffer = io.BytesIO()
cropped.save(buffer, format="PNG")
image_base64 = base64.b64encode(buffer.getvalue()).decode()
# HolySheep AI로 데이터 추출
chart_data = extract_chart_data(image_base64)
# Excel 저장
save_chart_to_excel(
chart_data,
f"{output_dir}/page{page_num + 1}_chart{idx + 1}.xlsx"
)
doc.close()
print(f"✅ PDF에서 {len(chart_regions)}개 차트 추출 완료")
except ImportError:
print("PyMuPDF 설치 필요: pip install pymupdf")
def detect_chart_regions(page_image: Image.Image) -> list:
"""HolySheep AI로 차트 영역 자동 탐지"""
# 이미지 Base64 인코딩
buffer = io.BytesIO()
page_image.save(buffer, format="PNG")
image_base64 = base64.b64encode(buffer.getvalue()).decode()
prompt = """이 PDF 페이지 이미지에서 차트가 포함된 모든 영역을 찾아.
출력 형식 (JSON 배열):
[
{"x": 좌상단X, "y": 좌상단Y, "width": 너비, "height": 높이, "type": "차트유형"},
...
]
차트 유형: bar, line, pie, scatter, stacked, grouped, area
좌표는 전체 이미지 기준 (픽셀 단위)
차트가 없으면 빈 배열 [] 반환"""
payload = {
"model": "gpt-4o",
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_base64}"
}
}
]
}
],
"max_tokens": 1024
}
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
response = requests.post(
f"{HOLYSHEEP_BASE_URL}/chat/completions",
headers=headers,
json=payload
)
if response.status_code != 200:
return []
result = response.json()
content = result["choices"][0]["message"]["content"]
# JSON 파싱
regions = json.loads(content)
return [tuple(r.values()) for r in regions]
def extract_chart_data(image_base64: str) -> dict:
"""차트 이미지에서 데이터 추출"""
prompt = """이 차트 이미지에서 모든 데이터 포인트를 정확히 추출.
요구사항:
1. 차트 유형 정확히 식별
2. X축, Y축 레이블 및 단위 추출
3. 모든 데이터 포인트의 정확한 수치값
4. 범례가 있으면 시리즈별 구분
5. 출처나 메모가 있으면 포함
출력은 유효한 JSON 형식으로만 반환."""
payload = {
"model": "claude-3-5-sonnet-20240620", # Claude로 정확도 향상
"max_tokens": 2048,
"messages": [
{
"role": "user",
"content": [
{"type": "text", "text": prompt},
{
"type": "image",
"source": {
"type": "base64",
"media_type": "image/png",
"data": image_base64
}
}
]
}
]
}
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
"Content-Type": "application/json"
}
response = requests.post(
f"{HOLYSHEEP_BASE_URL}/messages",
headers=headers,
json=payload
)
content = response.json()["content"][0]["text"]
return json.loads(content)
def save_chart_to_excel(data: dict, output_path: str):
"""추출 데이터를 Excel로 저장 (openpyxl 사용)"""
from openpyxl import Workbook
from openpyxl.styles import Font, Alignment, PatternFill
wb = Workbook()
ws = wb.active
ws.title = data.get("title", "차트 데이터")[:31]
# 헤더 스타일
header_fill = PatternFill(start_color="4472C4", end_color="4472C4", fill_type="solid")
header_font = Font(bold=True, color="FFFFFF")
# 데이터 쓰기
headers = ["카테고리/라벨", "값", "추가 정보"]
for col, header in enumerate(headers, start=1):
cell = ws.cell(row=1, column=col, value=header)
cell.fill = header_fill
cell.font = header_font
cell.alignment = Alignment(horizontal="center")
# 데이터 행
for row_idx, item in enumerate(data.get("data", []), start=2):
ws.cell(row=row_idx, column=1, value=item.get("category", ""))
ws.cell(row=row_idx, column=2, value=item.get("value", 0))
ws.cell(row=row_idx, column=3, value=str(item.get("additional", "")))
# 열 너비 자동 조정
for col in ws.columns:
max_length = 0
column = col[0].column_letter
for cell in col:
if cell.value:
max_length = max(max_length, len(str(cell.value)))
ws.column_dimensions[column].width = min(max_length + 2, 50)
wb.save(output_path)
실행
if __name__ == "__main__":
extract_charts_from_pdf("annual_report_2024.pdf", "./output")이런 팀에 적합 / 비적합
✅ 이런 팀에 적합합니다
- 재무/회계팀: 분기별 보고서, 애널리스트 보고서에서 차트 데이터 추출 필요. 연간 수백 개의 PDF에서 매출, 이익, 성장률 데이터 재입력 시간 80% 절감 가능.
- 마케팅/리서치팀: 경쟁사 분석 보고서, 시장 조사 자료의 그래프 데이터를 스프레드시트로 변환하여 분석. SurveyMonkey, Gartner 보고서 활용에 최적.
- 연구기관/학술팀: 논문 figures, 실험 데이터 그래프 추출. 표로 변환이 어려운 복잡한 데이터 시각화 처리.
- 스타트업 MVP: 최소 비용으로 PDF 자동화 파이프라인 구축. HolySheep 로컬 결제와 무료 크레딧으로 즉시 시작 가능.
- SI/컨설팅: 클라이언트 제공 PDF 자료 일괄 처리. 다중 모델 투표로 정확도 요구사항 충족.
❌ 이런 팀에는 적합하지 않을 수 있습니다
- 완전한 수동 정확도 필요: 법적 문서, 감사 보고서 등 100% 정확한 수치 요구 시에는 수동 검증 필수. AI 정확도는 93~97% 수준.
- 해외 결제 인프라 없는 소규모: 자체 서버 유지 가능한 대형 기업은 온프레미스 OCR 솔루션이 장기적으로 비용 효율적일 수 있음 (단, 초기 투자 $500~$10,000).
- 캡차/DRM 보호 PDF: 암호화된 PDF, 이미지 기반 스캔 문서는 OCR 전처리 필요. 복잡도 증가.
가격과 ROI
비용 분석: 월 500개 차트 처리 기준| 구분 | HolySheep AI | 수동 처리 | 절감 효과 |
|---|---|---|---|
| 월 처리량 | 500개 차트 | 500개 차트 | - |
| 시간 소요 | 약 4~6시간 (자동화) | 약 125~250시간 | 시간 절감 96~98% |
| API 비용 | $15~$35/월 | $0 | 인건비 $2,500~$5,000 절감 |
| 정확도 | 93~97% | 100% | 수동 검증 5~10% 필요 |
| 월간 ROI | 약 7,000~15,000% (비용 대비 시간 절감) | ||
- Gemini 2.5 Flash: $2.50/MTok 입력 — 단순 차트에 적합, 1개 차트당 약 $0.003
- GPT-4o: $5/MTok 입력 — 균형형, 1개 차트당 약 $0.005
- Claude Sonnet: $15/MTok 입력 — 복잡 차트, 1개 차트당 약 $0.015
- 월 500개 차트 처리 시: 약 $2~$8 (Gemini优先) ~ $25 (Claude 전용)
왜 HolySheep를 선택해야 하나
1. 단일 API 키로 다중 모델 활용 PDF 차트 추출에서는 차트 복잡도에 따라 최적 모델이 다릅니다. HolySheep는 GPT-4.1, Claude Sonnet, Gemini 2.5 Flash, DeepSeek V3를 단일 API 키로 전환하며 사용 가능. 저는 처음에는 Gemini로 단순 차트를 처리하고, 복잡한 스캐터차트는 Claude로 자동 라우팅하는 파이프라인을 구축했습니다. 2. 로컬 결제 지원 OpenAI, Anthropic 공식 API는 해외 신용카드 필수입니다. HolySheep는 국내 결제 수단으로 즉시 구매 가능하며, 개발자 친화적인 과금 체계로 소규모 사용에도 과도한 선불 비용이 없습니다. 3. 차트 추출에 최적화된 모델 조합 HolySheep의 모델 목록에서 차트 데이터 추출에 최적화된 조합:- 비용 우선: DeepSeek V3 ($0.42/MTok) — 90% 정확도, 단순 막대/파이차트
- 균형: Gemini 2.5 Flash ($2.50/MTok) — 92% 정확도, 일반 차트
- 정확도 우선: Claude Sonnet ($15/MTok) — 96% 정확도, 복잡 차트
자주 발생하는 오류와 해결책
오류 1: "Invalid image format" — 이미지 형식 오류
원인: PDF 변환 이미지가 JPEG 또는 WebP 형식으로 전송된 경우. Vision 모델은 PNG 또는 TIFF를 선호. 해결 코드:# 잘못된 예시
image = Image.open("chart.jpg") # JPEG 형식
buffer = io.BytesIO()
image.save(buffer, format="JPEG") # JPEG 저장
image_base64 = base64.b64encode(buffer.getvalue()).decode()
올바른 예시
from PIL import Image
import io
image = Image.open("chart.jpg") # 원본은 JPEG 가능
buffer = io.BytesIO()
PNG로 변환하여 저장
image.save(buffer, format="PNG", quality=95)
image_base64 = base64.b64encode(buffer.getvalue()).decode()
또는 RGB 모드 보장
if image.mode != "RGB":
image = image.convert("RGB")
image.save(buffer, format="PNG")
image_base64 = base64.b64encode(buffer.getvalue()).decode()오류 2: "Rate limit exceeded" — API 속도 제한
원인: 다중 병렬 요청 시 HolySheep 또는 원본 API의 Rate Limit 도달. 배치 처리 시 발생. 해결 코드:import time
import asyncio
from concurrent.futures import ThreadPoolExecutor
def extract_with_retry(image_base64, max_retries=3, delay=2):
"""재시도 로직 포함 차트 추출"""
for attempt in range(max_retries):
try:
result = extract_chart_data(image_base64)
return result
except Exception as e:
if "rate limit" in str(e).lower() and attempt < max_retries - 1:
wait_time = delay * (2 ** attempt) # 지수 백오프
print(f" Rate limit 도달. {wait_time}초 후 재시도 ({attempt + 1}/{max_retries})")
time.sleep(wait_time)
else:
raise
return None
배치 처리 with 속도 제한
async def batch_extract_async(image_list, max_concurrent=5):
"""비동기 배치 처리 with 동시 요청 제한"""
semaphore = asyncio.Semaphore(max_concurrent)
async def limited_extract(image_base64):
async with semaphore:
return await asyncio.to_thread(extract_with_retry, image_base64)
results = await asyncio.gather(*[limited_extract(img) for img in image_list])
return [r for r in results if r is not None]
실행
asyncio.run(batch_extract_async(all_chart_images, max_concurrent=5))오류 3: "JSON parse error" — 응답 파싱 실패
원인: AI 모델이 마크다운 코드 블록 없이 순수 JSON 반환하거나, 불완전한 JSON 응답. 해결 코드:import json
import re
def safe_json_parse(response_text):
"""강력한 JSON 파싱 및 복구"""
# 마크다운 코드 블록 제거
text = response_text.strip()
if text.startswith("```json"):
text = text[7:]
elif text.startswith("```"):
text = text[3:]
if text.endswith("```"):
text = text[:-3]
text = text.strip()
# JSON 직접 파싱 시도
try:
return json.loads(text)
except json.JSONDecodeError:
pass
# 불완전한 JSON 복구 시도
# 1. 마지막 쉼표 제거
text_fixed = re.sub(r',(\s*[}\]])', r'\1', text)
try:
return json.loads(text_fixed)
except json.JSONDecodeError:
pass
# 2. 따옴표 쌍 복구
def fix_incomplete_json(s):
# 첫 { 또는 [ 위치
start_idx = s.find('{')
if start_idx == -1:
start_idx = s.find('[')
if start_idx == -1:
return s
s = s[start_idx:]
# 여는/닫는 괄호 매칭