import json

# 기본 데이터 타입 변환
python_dict = {
    "name": "John",
    "age": 30,
    "city": "Seoul"
}

# Python -> JSON
json_str = json.dumps(python_dict)
print(json_str)  # {"name": "John", "age": 30, "city": "Seoul"}

# JSON -> Python
python_data = json.loads(json_str)
print(python_data["name"])  # John

# Python 타입과 JSON 타입 매핑
# dict -> object, list/tuple -> array, str -> string, 
# int/float -> number, True/False -> true/false, None -> null

# 한글 및 유니코드 처리
korean_data = {"이름": "홍길동", "도시": "서울"}
json_str = json.dumps(korean_data, ensure_ascii=False)
print(json_str)  # {"이름": "홍길동", "도시": "서울"}

# JSON 파일 쓰기
data = {
    "users": [
        {"id": 1, "name": "Alice"},
        {"id": 2, "name": "Bob"}
    ]
}

with open('data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, indent=4)

# JSON 파일 읽기
with open('data.json', 'r', encoding='utf-8') as f:
    loaded_data = json.load(f)

# 여러 옵션 활용
with open('formatted_data.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, 
              indent=2,           # 들여쓰기 간격 설정
              sort_keys=True,     # 키를 알파벳 순으로 정렬
              ensure_ascii=False, # 비ASCII 문자 그대로 출력
              separators=(',', ': '))  # 구분자 지정

# 대용량 파일 처리
def read_json_stream(file_path):
    """대용량 JSON 파일을 한 줄씩 처리"""
    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f:
            if line.strip():  # 빈 줄 건너뛰기
                yield json.loads(line)

# JSONL(JSON Lines) 형식 처리
def write_jsonl(data_list, file_path):
    """각 항목을 JSON Lines 형식으로 저장"""
    with open(file_path, 'w', encoding='utf-8') as f:
        for item in data_list:
            f.write(json.dumps(item, ensure_ascii=False) + '\n')

from datetime import datetime
from decimal import Decimal
import uuid

class CustomEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, Decimal):
            return str(obj)
        if isinstance(obj, uuid.UUID):
            return str(obj)
        # 사용자 정의 클래스 처리
        if hasattr(obj, 'to_json'):
            return obj.to_json()
        return super().default(obj)

# 사용자 정의 클래스
class User:
    def __init__(self, name, created_at):
        self.name = name
        self.created_at = created_at
        self.id = uuid.uuid4()
    
    def to_json(self):
        return {
            'name': self.name,
            'created_at': self.created_at,
            'id': self.id
        }

data = {
    'user': User('John Doe', datetime.now()),
    'balance': Decimal('10.52'),
    'transaction_id': uuid.uuid4()
}

json_str = json.dumps(data, cls=CustomEncoder, indent=2)
print(json_str)

# 직렬화/역직렬화 함수 사용
def serialize(obj):
    """객체를 JSON 문자열로 변환"""
    return json.dumps(obj, cls=CustomEncoder)

def deserialize(json_str, custom_decoder=None):
    """JSON 문자열을 객체로 변환"""
    if custom_decoder:
        return json.loads(json_str, object_hook=custom_decoder)
    return json.loads(json_str)

# object_hook으로 커스텀 객체 복원
def user_decoder(obj):
    if 'name' in obj and 'created_at' in obj and 'id' in obj:
        user = User(obj['name'], datetime.fromisoformat(obj['created_at']))
        user.id = uuid.UUID(obj['id'])
        return user
    return obj

from jsonschema import validate, ValidationError, Draft7Validator

# 기본 스키마 정의
schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "age": {"type": "integer", "minimum": 0},
        "email": {"type": "string", "format": "email"},
        "tags": {
            "type": "array",
            "items": {"type": "string"},
            "minItems": 1
        },
        "address": {
            "type": "object", 
            "properties": {
                "street": {"type": "string"},
                "city": {"type": "string"},
                "country": {"type": "string"}
            },
            "required": ["street", "city"]
        }
    },
    "required": ["name", "age", "email"]
}

# 검증 함수
def validate_json(data, schema):
    try:
        validate(instance=data, schema=schema)
        return True, None
    except ValidationError as e:
        return False, str(e)

# 사용 예시
user_data = {
    "name": "Alice Smith",
    "age": 25,
    "email": "[email protected]",
    "tags": ["developer", "python"],
    "address": {
        "street": "123 Main St",
        "city": "New York"
    }
}

is_valid, error = validate_json(user_data, schema)
if is_valid:
    print("데이터가 유효합니다.")
else:
    print(f"검증 실패: {error}")

# 모든 에러 한번에 수집하기
def collect_all_errors(data, schema):
    validator = Draft7Validator(schema)
    errors = list(validator.iter_errors(data))
    return [str(error) for error in errors]

# 스키마 동적 생성
def generate_schema_from_data(data):
    """샘플 데이터로부터 기본 스키마 생성"""
    schema = {"type": "object", "properties": {}}
    for key, value in data.items():
        if isinstance(value, str):
            schema["properties"][key] = {"type": "string"}
        elif isinstance(value, int):
            schema["properties"][key] = {"type": "integer"}
        elif isinstance(value, float):
            schema["properties"][key] = {"type": "number"}
        elif isinstance(value, bool):
            schema["properties"][key] = {"type": "boolean"}
        elif isinstance(value, list):
            schema["properties"][key] = {"type": "array"}
        elif isinstance(value, dict):
            schema["properties"][key] = {"type": "object"}
        elif value is None:
            schema["properties"][key] = {"type": "null"}
    
    return schema

# 설정 관리 클래스
class Config:
    def __init__(self, config_file):
        self.config_file = config_file
        self.config = self.load_config()
    
    def load_config(self):
        try:
            with open(self.config_file, 'r', encoding='utf-8') as f:
                return json.load(f)
        except FileNotFoundError:
            return self.create_default_config()
    
    def save_config(self):
        with open(self.config_file, 'w', encoding='utf-8') as f:
            json.dump(self.config, f, indent=4, ensure_ascii=False)
    
    def create_default_config(self):
        default_config = {
            "app_name": "MyApp",
            "version": "1.0.0",
            "debug": True,
            "logging": {
                "level": "INFO",
                "file": "app.log"
            },
            "database": {
                "host": "localhost",
                "port": 5432,
                "name": "mydb"
            }
        }
        return default_config
    
    def get(self, key, default=None):
        """설정 값 가져오기 (점 표기법 지원)"""
        keys = key.split('.')
        value = self.config
        try:
            for k in keys:
                value = value[k]
            return value
        except (KeyError, TypeError):
            return default
    
    def set(self, key, value):
        """설정 값 설정하기 (점 표기법 지원)"""
        keys = key.split('.')
        config = self.config
        for k in keys[:-1]:
            if k not in config or not isinstance(config[k], dict):
                config[k] = {}
            config = config[k]
        config[keys[-1]] = value
        self.save_config()

# RESTful API 응답 처리
def json_response(data, status=200):
    """JSON API 응답 생성"""
    from flask import Response  # 필요에 따라 설치: pip install flask
    return Response(
        json.dumps(data, ensure_ascii=False),
        status=status,
        mimetype='application/json; charset=utf-8'
    )

# JSON 데이터 병합
def merge_json(base, override):
    """두 JSON 객체 병합 (중첩 구조 지원)"""
    if not isinstance(base, dict) or not isinstance(override, dict):
        return override
    
    result = base.copy()
    for key, value in override.items():
        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
            result[key] = merge_json(result[key], value)
        else:
            result[key] = value
    return result

# JSON 차이 찾기
def find_json_diff(old, new):
    """두 JSON 객체 간의 차이점 찾기"""
    diff = {}
    
    # old에는 있지만 new에는 없는 키
    for key in old:
        if key not in new:
            diff[key] = {"old": old[key], "new": None}
    
    # 키가 양쪽 모두에 있지만 값이 다른 경우
    for key in new:
        if key in old:
            if isinstance(old[key], dict) and isinstance(new[key], dict):
                nested_diff = find_json_diff(old[key], new[key])
                if nested_diff:
                    diff[key] = nested_diff
            elif old[key] != new[key]:
                diff[key] = {"old": old[key], "new": new[key]}
        else:
            diff[key] = {"old": None, "new": new[key]}
    
    return diff

import requests
import json

# API 요청 및 JSON 처리
def fetch_data_from_api(url, params=None):
    try:
        response = requests.get(url, params=params)
        response.raise_for_status()  # 4xx, 5xx 에러 확인
        return response.json()  # JSON 응답을 파싱하여 Python 객체로 변환
    except requests.exceptions.RequestException as e:
        print(f"API 요청 에러: {e}")
        return None
    except json.JSONDecodeError as e:
        print(f"JSON 파싱 에러: {e}")
        return None

# 데이터 POST 요청
def post_data_to_api(url, data):
    headers = {'Content-Type': 'application/json'}
    try:
        response = requests.post(
            url, 
            data=json.dumps(data, ensure_ascii=False),
            headers=headers
        )
        response.raise_for_status()
        return response.json()
    except (requests.exceptions.RequestException, json.JSONDecodeError) as e:
        print(f"API 요청 에러: {e}")
        return None

# 간단한 REST API 클라이언트
class RestClient:
    def __init__(self, base_url, token=None):
        self.base_url = base_url
        self.headers = {'Content-Type': 'application/json'}
        if token:
            self.headers['Authorization'] = f'Bearer {token}'
    
    def get(self, endpoint, params=None):
        url = f"{self.base_url}/{endpoint}"
        response = requests.get(url, params=params, headers=self.headers)
        response.raise_for_status()
        return response.json()
    
    def post(self, endpoint, data):
        url = f"{self.base_url}/{endpoint}"
        response = requests.post(
            url, 
            data=json.dumps(data, ensure_ascii=False),
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()
    
    def put(self, endpoint, data):
        url = f"{self.base_url}/{endpoint}"
        response = requests.put(
            url, 
            data=json.dumps(data, ensure_ascii=False),
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()
    
    def delete(self, endpoint):
        url = f"{self.base_url}/{endpoint}"
        response = requests.delete(url, headers=self.headers)
        response.raise_for_status()
        return response.status_code == 204 or response.json()

import json
import time
import orjson  # pip install orjson
import ujson   # pip install ujson

# 성능 비교
def compare_json_libs(data, iterations=1000):
    """다양한 JSON 라이브러리 성능 비교"""
    results = {}
    
    # 표준 json 모듈
    start = time.time()
    for _ in range(iterations):
        json_str = json.dumps(data)
        json_obj = json.loads(json_str)
    results['json'] = time.time() - start
    
    # ujson 모듈
    try:
        start = time.time()
        for _ in range(iterations):
            json_str = ujson.dumps(data)
            json_obj = ujson.loads(json_str)
        results['ujson'] = time.time() - start
    except ImportError:
        results['ujson'] = "모듈 없음"
    
    # orjson 모듈
    try:
        start = time.time()
        for _ in range(iterations):
            json_str = orjson.dumps(data)
            json_obj = orjson.loads(json_str)
        results['orjson'] = time.time() - start
    except ImportError:
        results['orjson'] = "모듈 없음"
    
    return results

# 스트리밍 처리로 대용량 JSON 처리
def process_large_json_stream(file_path, process_func):
    """대용량 JSON 파일을 스트리밍 방식으로 처리"""
    import ijson  # pip install ijson
    
    with open(file_path, 'rb') as f:
        # 특정 패턴에 맞는 객체만 추출하여 처리
        for item in ijson.items(f, 'items.item'):
            process_func(item)

# 메모리 효율적인 JSON 생성
def generate_large_json(file_path, n_items, chunk_size=1000):
    """메모리 효율적으로 대용량 JSON 파일 생성"""
    with open(file_path, 'w', encoding='utf-8') as f:
        f.write('{"items": [')
        
        for i in range(n_items):
            item = {
                "id": i,
                "name": f"Item {i}",
                "value": i * 10
            }
            
            if i > 0:
                f.write(',')
            
            f.write(json.dumps(item))
            
            # 메모리 확보를 위해 주기적으로 flush
            if i % chunk_size == 0:
                f.flush()
        
        f.write(']}')