def calculate_total(items):
    total = 0
    for item in items:
        print(f"현재 아이템: {item}")  # 디버깅용 출력
        total += item
        print(f"현재 합계: {total}")   # 디버깅용 출력
    return total

# 실행
items = [1, 2, 3, 4, 5]
result = calculate_total(items)
print(f"최종 결과: {result}")

import pdb

def complex_function(data):
    result = []
    for item in data:
        # 브레이크포인트 설정
        pdb.set_trace()  # Python 3.7 이하
        # breakpoint()  # Python 3.7 이상
        processed = item * 2
        result.append(processed)
    return result

# pdb 명령어
"""
n(next): 다음 줄 실행
s(step): 함수 내부로 들어가기
c(continue): 다음 브레이크포인트까지 실행
p variable: 변수 출력
l(list): 현재 위치 주변 코드 출력
w(where): 콜스택 출력
q(quit): 디버거 종료
"""

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def get_info(self):
        # IDE에서 브레이크포인트 설정
        info = f"이름: {self.name}, 나이: {self.age}"
        processed_info = self.process_info(info)
        return processed_info
    
    def process_info(self, info):
        # 여기서도 브레이크포인트 설정 가능
        return info.upper()

import logging

# 로깅 설정
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='debug.log'
)

logger = logging.getLogger(__name__)

def process_data(data):
    logger.debug(f"데이터 처리 시작: {data}")
    try:
        result = data * 2
        logger.info(f"데이터 처리 완료: {result}")
        return result
    except Exception as e:
        logger.error(f"에러 발생: {str(e)}")
        raise

# 고급 로깅 설정 예시
import logging
from logging.handlers import RotatingFileHandler
import traceback

# 로거 생성
logger = logging.getLogger('my_app')
logger.setLevel(logging.DEBUG)

# 파일 핸들러 (크기 기반 로테이션)
file_handler = RotatingFileHandler('app.log', maxBytes=1024*1024, backupCount=5)
file_handler.setLevel(logging.INFO)

# 콘솔 핸들러
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)

# 포맷 지정
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 핸들러 추가
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# 로깅 사용 예
def complex_operation(x, y):
    logger.debug(f"complex_operation 시작: x={x}, y={y}")
    try:
        result = x / y
        logger.info(f"계산 결과: {result}")
        return result
    except Exception as e:
        logger.error(f"에러 발생: {str(e)}\n{traceback.format_exc()}")
        raise

# Python Debugger (ipdb)
"""
pip install ipdb
import ipdb; ipdb.set_trace()
"""

# pudb (시각적 디버거)
"""
pip install pudb
import pudb; pudb.set_trace()
"""

# 변수 검사
from pprint import pprint

def inspect_object(obj):
    print("\n== 객체 정보 ==")
    pprint(vars(obj))
    print("\n== 타입 정보 ==")
    pprint(dir(obj))

def robust_function(data):
    try:
        result = process_data(data)
        return result
    except ValueError as e:
        print(f"값 오류: {str(e)}")
        # 디버깅을 위한 추가 정보
        print(f"문제 데이터: {data}")
        return None
    except TypeError as e:
        print(f"타입 오류: {str(e)}")
        # 타입 정보 출력
        print(f"데이터 타입: {type(data)}")
        return None
    except Exception as e:
        # 예상치 못한 예외의 전체 스택 트레이스 출력
        import traceback
        print(f"예상치 못한 오류: {str(e)}")
        traceback.print_exc()
        return None

# 사용자 정의 예외 예시
class DataValidationError(Exception):
    def __init__(self, message, invalid_fields=None):
        super().__init__(message)
        self.invalid_fields = invalid_fields or []
        self.timestamp = datetime.now()
    
    def __str__(self):
        return f"{super().__str__()} (잘못된 필드: {self.invalid_fields}, 시간: {self.timestamp})"

# 사용 예시
def validate_user_data(user_data):
    invalid_fields = []
    
    if not isinstance(user_data.get('age'), int):
        invalid_fields.append('age')
    
    if not isinstance(user_data.get('name'), str):
        invalid_fields.append('name')
    
    if invalid_fields:
        raise DataValidationError("사용자 데이터 유효성 검사 실패", invalid_fields)
    
    return True

# 시간 측정
import time

def measure_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 실행 시간: {end_time - start_time:.6f}초")
        return result
    return wrapper

@measure_time
def slow_function(size):
    result = []
    for i in range(size):
        result.append(i ** 2)
    return result

# 프로파일링
import cProfile

def profile_function(func, *args, **kwargs):
    profiler = cProfile.Profile()
    profiler.enable()
    result = func(*args, **kwargs)
    profiler.disable()
    profiler.print_stats(sort='cumtime')
    return result

# 사용 예시
profile_function(slow_function, 10000)

# 고급 시간 측정 컨텍스트 매니저
import time
from contextlib import contextmanager

@contextmanager
def timer(name="작업"):
    start_time = time.time()
    yield
    elapsed = time.time() - start_time
    print(f"{name} 완료: {elapsed:.6f}초")

# 사용 예시
with timer("데이터 처리"):
    result = process_large_dataset()

import threading
import logging

# 스레드 디버깅을 위한 로깅 설정
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(threadName)s - %(message)s'
)

def thread_function(name, data):
    logging.debug(f"스레드 {name} 시작")
    try:
        # 작업 수행
        result = process_data(data)
        logging.debug(f"스레드 {name} 결과: {result}")
    except Exception as e:
        logging.error(f"스레드 {name} 오류: {str(e)}")
    finally:
        logging.debug(f"스레드 {name} 종료")

# 비동기 코드 디버깅
import asyncio

async def async_function(name, data):
    print(f"비동기 함수 {name} 시작")
    try:
        # 비동기 작업 시뮬레이션
        await asyncio.sleep(1)
        result = data * 2
        print(f"비동기 함수 {name} 결과: {result}")
        return result
    except Exception as e:
        print(f"비동기 함수 {name} 오류: {str(e)}")
        raise

# 로깅 기반 원격 디버깅
import logging
import json
import socket

class ContextFilter(logging.Filter):
    def __init__(self):
        self.hostname = socket.gethostname()
        
    def filter(self, record):
        record.hostname = self.hostname
        return True

# 원격 로깅 설정
def setup_remote_logging():
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    
    # 컨텍스트 필터 추가
    context_filter = ContextFilter()
    logger.addFilter(context_filter)
    
    # JSON 포맷터
    class JsonFormatter(logging.Formatter):
        def format(self, record):
            log_record = {
                'time': self.formatTime(record),
                'name': record.name,
                'level': record.levelname,
                'hostname': getattr(record, 'hostname', ''),
                'message': record.getMessage(),
                'path': record.pathname,
                'line': record.lineno
            }
            if record.exc_info:
                log_record['exception'] = self.formatException(record.exc_info)
            return json.dumps(log_record)
    
    # 핸들러 설정
    handler = logging.FileHandler('app.log')
    handler.setFormatter(JsonFormatter())
    logger.addHandler(handler)
    
    return logger

# 모의 객체(Mock)를 사용한 디버깅
from unittest.mock import patch, MagicMock

def test_with_mock():
    # 외부 API 호출을 모의 객체로 대체
    with patch('module.api_call') as mock_api:
        # 모의 반환값 설정
        mock_api.return_value = {'status': 'success', 'data': [1, 2, 3]}
        
        # 테스트 대상 함수 호출
        result = process_api_data()
        
        # 호출 검증
        mock_api.assert_called_once()
        print(f"API 호출 인자: {mock_api.call_args}")
        
        # 결과 검증
        assert result == [2, 4, 6]

# 디버깅을 위한 데코레이터
def debug_function_calls(func):
    def wrapper(*args, **kwargs):
        args_repr = [repr(a) for a in args]
        kwargs_repr = [f"{k}={v!r}" for k, v in kwargs.items()]
        signature = ", ".join(args_repr + kwargs_repr)
        print(f"함수 호출: {func.__name__}({signature})")
        try:
            result = func(*args, **kwargs)
            print(f"함수 반환: {func.__name__} -> {result!r}")
            return result
        except Exception as e:
            print(f"함수 예외: {func.__name__} -> {type(e).__name__}: {e}")
            raise
    return wrapper

@debug_function_calls
def complex_calculation(x, y, z=1):
    return (x * y) / z