## 🎯 CLI 도구, 왜 만들어야 할까? 여러분, 혹시 터미널 창에서 git commit이나 npm install 같은 명령어를 입력해본 적 있나요? 이런 명령어들이 바로 CLI(Command Line Interface) 도구예요! 😊

개발자라면 반복적인 작업을 자동화하거나, 팀원들과 공유할 수 있는 도구를 만들고 싶을 때가 있죠. 예를 들어 데이터베이스 백업, 로그 분석, 파일 변환 같은 작업들을 매번 수동으로 하기엔 너무 귀찮잖아요? 이럴 때 CLI 도구를 만들면 정말 편리합니다! 🎉

파이썬에는 CLI 도구를 만들 수 있는 여러 라이브러리가 있어요. argparse는 기본 내장 라이브러리지만 코드가 길어지고 복잡해요. docopt은 독특한 접근 방식이지만 유연성이 떨어지죠. 그런데 Click 라이브러리는 정말 직관적이고 우아하게 CLI 도구를 만들 수 있답니다! 💎 ## 📦 Click 설치하기 Click을 사용하기 위해서는 먼저 설치가 필요해요. 정말 간단합니다! 😄

pip install click

만약 특정 버전을 설치하고 싶다면 이렇게 할 수 있어요:

pip install click==8.1.7

설치가 완료되었는지 확인하려면:

python -c "import click; print(click.__version__)"

버전 정보가 출력되면 성공입니다! 🎊 ## 🌟 첫 번째 Click 프로그램 만들기 자, 이제 본격적으로 Click을 사용해볼까요? 가장 간단한 "Hello World" 프로그램부터 시작해봅시다! 👋

import click

@click.command()
def hello():
    """간단한 인사 프로그램"""
    click.echo('안녕하세요! Click의 세계에 오신 것을 환영합니다! 🎉')

if __name__ == '__main__':
    hello()

이 코드를 hello.py로 저장하고 실행해보세요:

python hello.py

도움말을 보고 싶다면 --help 옵션을 추가하세요:

python hello.py --help

짜잔! 자동으로 생성된 도움말이 나타납니다. 이게 Click의 마법이에요! ✨ ## 🎛️ 옵션과 인자 다루기 CLI 도구의 핵심은 사용자로부터 입력을 받는 거죠. Click에서는 옵션(Option)과 인자(Argument) 두 가지 방식으로 입력을 받을 수 있어요! 🎯 ### 옵션(Option) 사용하기 옵션은 --name이나 -n 같은 형태로 사용되는 선택적 매개변수예요:

import click

@click.command()
@click.option('--name', default='친구', help='인사할 사람의 이름')
@click.option('--count', default=1, help='인사 반복 횟수')
def greet(name, count):
    """이름을 받아서 인사하는 프로그램"""
    for _ in range(count):
        click.echo(f'안녕하세요, {name}님! 😊')

if __name__ == '__main__':
    greet()

이제 다양한 방식으로 실행할 수 있어요:

# 기본값 사용
python greet.py

# 이름 지정
python greet.py --name 철수

# 반복 횟수 지정
python greet.py --name 영희 --count 3

# 짧은 옵션 사용 (정의하면)
python greet.py -n 민수 -c 2

### 인자(Argument) 사용하기 인자는 옵션과 달리 필수 입력값이에요. 명령어 바로 뒤에 입력하죠:

import click

@click.command()
@click.argument('filename')
def process_file(filename):
    """파일을 처리하는 프로그램"""
    click.echo(f'📁 {filename} 파일을 처리하고 있습니다...')
    # 실제 파일 처리 로직
    click.echo('✅ 처리 완료!')

if __name__ == '__main__':
    process_file()

실행 방법:

python process.py data.txt

### 타입 지정하기 Click은 자동으로 타입을 변환해줘요! 정말 편리하죠? 😍

import click

@click.command()
@click.option('--age', type=int, help='나이')
@click.option('--height', type=float, help='키 (cm)')
@click.option('--active', type=bool, help='활성 상태')
def user_info(age, height, active):
    """사용자 정보를 출력하는 프로그램"""
    click.echo(f'나이: {age}세 (타입: {type(age).__name__})')
    click.echo(f'키: {height}cm (타입: {type(height).__name__})')
    click.echo(f'활성: {active} (타입: {type(active).__name__})')

if __name__ == '__main__':
    user_info()

잘못된 타입을 입력하면 Click이 자동으로 에러 메시지를 보여줘요:

python user.py --age 스물다섯
# Error: Invalid value for '--age': '스물다섯' is not a valid integer.

## 🎨 고급 옵션 기능들 Click은 정말 다양한 옵션 기능을 제공해요. 하나씩 살펴볼까요? 🚀 ### 플래그(Flag) 옵션 불리언 값을 다루는 특별한 방식이에요:

import click

@click.command()
@click.option('--verbose', '-v', is_flag=True, help='상세 정보 출력')
@click.option('--quiet', '-q', is_flag=True, help='최소 정보만 출력')
def process(verbose, quiet):
    """처리 프로그램"""
    if verbose:
        click.echo('🔍 상세 모드: 모든 정보를 출력합니다.')
        click.echo('단계 1: 초기화 중...')
        click.echo('단계 2: 데이터 로딩...')
        click.echo('단계 3: 처리 중...')
    elif quiet:
        click.echo('완료')
    else:
        click.echo('✅ 처리가 완료되었습니다.')

if __name__ == '__main__':
    process()

사용 예시:

python process.py          # 일반 모드
python process.py -v       # 상세 모드
python process.py --quiet  # 조용한 모드

### 선택지(Choice) 옵션 미리 정의된 값 중에서만 선택하도록 제한할 수 있어요:

import click

@click.command()
@click.option('--format', 
              type=click.Choice(['json', 'xml', 'csv', 'yaml'], case_sensitive=False),
              default='json',
              help='출력 형식')
def export(format):
    """데이터를 내보내는 프로그램"""
    click.echo(f'📤 {format.upper()} 형식으로 내보내는 중...')
    
    if format == 'json':
        click.echo('{"status": "success", "data": [...]}')
    elif format == 'xml':
        click.echo('<response><status>success</status></response>')
    elif format == 'csv':
        click.echo('id,name,value\n1,test,100')
    else:
        click.echo('status: success\ndata: []')

if __name__ == '__main__':
    export()

잘못된 선택지를 입력하면:

python export.py --format txt
# Error: Invalid value for '--format': 'txt' is not one of 'json', 'xml', 'csv', 'yaml'.

### 다중 값 옵션 여러 개의 값을 받을 수 있어요:

import click

@click.command()
@click.option('--tag', multiple=True, help='태그 추가 (여러 번 사용 가능)')
def create_post(tag):
    """블로그 포스트를 생성하는 프로그램"""
    click.echo('📝 새 포스트 생성 중...')
    
    if tag:
        click.echo(f'🏷️  태그: {", ".join(tag)}')
    else:
        click.echo('태그가 지정되지 않았습니다.')

if __name__ == '__main__':
    create_post()

사용 예시:

python post.py --tag python --tag cli --tag tutorial
# 출력: 🏷️  태그: python, cli, tutorial

### 프롬프트(Prompt) 옵션 값이 제공되지 않으면 사용자에게 물어봐요:

import click

@click.command()
@click.option('--username', prompt='사용자 이름을 입력하세요', help='사용자 이름')
@click.option('--password', prompt=True, hide_input=True, confirmation_prompt=True, help='비밀번호')
def login(username, password):
    """로그인 프로그램"""
    click.echo(f'👤 {username}님, 로그인 시도 중...')
    # 실제 인증 로직
    click.echo('✅ 로그인 성공!')

if __name__ == '__main__':
    login()

실행하면 이렇게 동작해요:

python login.py
사용자 이름을 입력하세요: 철수
Password: ****
Repeat for confirmation: ****
👤 철수님, 로그인 시도 중...
✅ 로그인 성공!

### 범위 제한 숫자 입력의 범위를 제한할 수 있어요:

import click

@click.command()
@click.option('--volume', type=click.IntRange(0, 100), default=50, help='볼륨 (0-100)')
@click.option('--quality', type=click.FloatRange(0.0, 1.0), default=0.8, help='품질 (0.0-1.0)')
def settings(volume, quality):
    """설정 프로그램"""
    click.echo(f'🔊 볼륨: {volume}%')
    click.echo(f'⭐ 품질: {quality * 100:.0f}%')

if __name__ == '__main__':
    settings()

범위를 벗어나면:

python settings.py --volume 150
# Error: Invalid value for '--volume': 150 is not in the range 0<=x<=100.

## 🏗️ 명령어 그룹 만들기 실제 CLI 도구는 여러 개의 하위 명령어를 가지고 있죠. git을 생각해보세요: git commit, git push, git pull 같은 것들이요! Click에서는 이런 구조를 쉽게 만들 수 있어요. 🎪 ### 기본 그룹 구조

import click

@click.group()
def cli():
    """데이터베이스 관리 도구"""
    pass

@cli.command()
def init():
    """데이터베이스 초기화"""
    click.echo('🗄️  데이터베이스를 초기화하고 있습니다...')
    click.echo('✅ 초기화 완료!')

@cli.command()
@click.option('--table', required=True, help='백업할 테이블 이름')
def backup(table):
    """데이터베이스 백업"""
    click.echo(f'💾 {table} 테이블을 백업하고 있습니다...')
    click.echo('✅ 백업 완료!')

@cli.command()
def status():
    """데이터베이스 상태 확인"""
    click.echo('📊 데이터베이스 상태:')
    click.echo('  - 연결: 정상')
    click.echo('  - 테이블 수: 15')
    click.echo('  - 저장 공간: 2.3GB')

if __name__ == '__main__':
    cli()

이제 이렇게 사용할 수 있어요:

python db.py --help        # 전체 도움말
python db.py init          # 초기화
python db.py backup --table users  # 백업
python db.py status        # 상태 확인

### 중첩된 그룹 그룹 안에 또 다른 그룹을 만들 수도 있어요:

import click

@click.group()
def cli():
    """클라우드 관리 도구"""
    pass

@cli.group()
def server():
    """서버 관리"""
    pass

@server.command()
@click.option('--name', required=True, help='서버 이름')
def start(name):
    """서버 시작"""
    click.echo(f'🚀 {name} 서버를 시작합니다...')

@server.command()
@click.option('--name', required=True, help='서버 이름')
def stop(name):
    """서버 중지"""
    click.echo(f'🛑 {name} 서버를 중지합니다...')

@cli.group()
def database():
    """데이터베이스 관리"""
    pass

@database.command()
def migrate():
    """마이그레이션 실행"""
    click.echo('🔄 마이그레이션을 실행합니다...')

if __name__ == '__main__':
    cli()

사용 예시:

python cloud.py server start --name web-01
python cloud.py server stop --name web-01
python cloud.py database migrate

### 컨텍스트(Context) 활용하기 명령어 간에 데이터를 공유하고 싶을 때 컨텍스트를 사용해요:

import click

@click.group()
@click.option('--debug/--no-debug', default=False, help='디버그 모드')
@click.pass_context
def cli(ctx, debug):
    """애플리케이션 관리 도구"""
    ctx.ensure_object(dict)
    ctx.obj['DEBUG'] = debug
    
    if debug:
        click.echo('🐛 디버그 모드가 활성화되었습니다.')

@cli.command()
@click.pass_context
def deploy(ctx):
    """애플리케이션 배포"""
    if ctx.obj['DEBUG']:
        click.echo('[DEBUG] 배포 프로세스 시작...')
        click.echo('[DEBUG] 환경 변수 확인 중...')
        click.echo('[DEBUG] 빌드 파일 검증 중...')
    
    click.echo('🚀 애플리케이션을 배포합니다...')
    click.echo('✅ 배포 완료!')

@cli.command()
@click.pass_context
def test(ctx):
    """테스트 실행"""
    if ctx.obj['DEBUG']:
        click.echo('[DEBUG] 테스트 환경 설정 중...')
        click.echo('[DEBUG] 테스트 케이스 로딩...')
    
    click.echo('🧪 테스트를 실행합니다...')
    click.echo('✅ 모든 테스트 통과!')

if __name__ == '__main__':
    cli()

실행:

python app.py --debug deploy
# 디버그 정보와 함께 배포 실행

python app.py test
# 일반 모드로 테스트 실행

## 📂 파일과 경로 다루기 CLI 도구에서 파일을 다루는 건 정말 흔한 일이죠. Click은 파일 처리를 위한 특별한 타입들을 제공해요! 📁 ### File 타입 사용하기

import click

@click.command()
@click.option('--input', type=click.File('r'), help='입력 파일')
@click.option('--output', type=click.File('w'), default='-', help='출력 파일 (기본: 표준출력)')
def convert(input, output):
    """파일 변환 도구"""
    if input:
        click.echo('📖 파일을 읽고 있습니다...')
        content = input.read()
        
        # 간단한 변환 예시: 대문자로 변환
        converted = content.upper()
        
        output.write(converted)
        click.echo('✅ 변환 완료!')
    else:
        click.echo('입력 파일이 지정되지 않았습니다.')

if __name__ == '__main__':
    convert()

사용 예시:

# 파일에서 읽어서 파일로 쓰기
python convert.py --input data.txt --output result.txt

# 파일에서 읽어서 화면에 출력
python convert.py --input data.txt

# 표준 입력에서 읽기
echo "hello world" | python convert.py --output result.txt

### Path 타입 사용하기 파일이나 디렉토리 경로를 검증하고 싶을 때:

import click
import os

@click.command()
@click.option('--source', 
              type=click.Path(exists=True, file_okay=True, dir_okay=False, readable=True),
              required=True,
              help='원본 파일')
@click.option('--dest',
              type=click.Path(file_okay=True, dir_okay=False, writable=True),
              required=True,
              help='대상 파일')
def copy_file(source, dest):
    """파일 복사 도구"""
    click.echo(f'📋 {source} → {dest}')
    
    # 실제 복사 로직
    with open(source, 'rb') as src:
        with open(dest, 'wb') as dst:
            dst.write(src.read())
    
    size = os.path.getsize(dest)
    click.echo(f'✅ 복사 완료! ({size:,} bytes)')

if __name__ == '__main__':
    copy_file()

### 디렉토리 작업

import click
import os

@click.command()
@click.option('--dir',
              type=click.Path(exists=True, file_okay=False, dir_okay=True),
              required=True,
              help='스캔할 디렉토리')
@click.option('--ext', default='.txt', help='파일 확장자')
def scan(dir, ext):
    """디렉토리 스캔 도구"""
    click.echo(f'🔍 {dir} 디렉토리를 스캔합니다...\n')
    
    files = []
    for root, dirs, filenames in os.walk(dir):
        for filename in filenames:
            if filename.endswith(ext):
                filepath = os.path.join(root, filename)
                size = os.path.getsize(filepath)
                files.append((filepath, size))
    
    if files:
        click.echo(f'📁 {ext} 파일 {len(files)}개 발견:\n')
        total_size = 0
        for filepath, size in files:
            click.echo(f'  • {filepath} ({size:,} bytes)')
            total_size += size
        
        click.echo(f'\n📊 총 크기: {total_size:,} bytes')
    else:
        click.echo(f'❌ {ext} 파일을 찾을 수 없습니다.')

if __name__ == '__main__':
    scan()

## 🎨 출력 스타일링 터미널 출력을 예쁘게 꾸미면 사용자 경험이 훨씬 좋아져요! Click은 색상과 스타일을 쉽게 적용할 수 있어요. 🌈 ### 색상 사용하기

import click

@click.command()
def colorful():
    """다양한 색상 출력"""
    click.echo(click.style('✅ 성공 메시지', fg='green', bold=True))
    click.echo(click.style('⚠️  경고 메시지', fg='yellow', bold=True))
    click.echo(click.style('❌ 에러 메시지', fg='red', bold=True))
    click.echo(click.style('ℹ️  정보 메시지', fg='blue'))
    click.echo(click.style('🔍 디버그 메시지', fg='cyan', dim=True))
    
    # 배경색도 사용 가능
    click.echo(click.style('중요한 알림!', fg='white', bg='red', bold=True))
    
    # 여러 스타일 조합
    click.echo(click.style('밑줄 + 굵게', underline=True, bold=True))
    click.echo(click.style('깜빡임 효과', blink=True))

if __name__ == '__main__':
    colorful()

### 진행 표시줄(Progress Bar) 긴 작업을 할 때 진행 상황을 보여주면 좋죠:

import click
import time

@click.command()
@click.option('--count', default=100, help='처리할 항목 수')
def process(count):
    """진행 표시줄 예제"""
    click.echo('🚀 작업을 시작합니다...\n')
    
    with click.progressbar(range(count), label='처리 중') as bar:
        for item in bar:
            # 실제 작업 시뮬레이션
            time.sleep(0.02)
    
    click.echo('\n✅ 모든 작업이 완료되었습니다!')

if __name__ == '__main__':
    process()

더 세밀한 제어가 필요하다면:

import click
import time

@click.command()
def download():
    """파일 다운로드 시뮬레이션"""
    files = ['file1.zip', 'file2.zip', 'file3.zip', 'file4.zip', 'file5.zip']
    
    with click.progressbar(
        files,
        label='다운로드 중',
        fill_char='█',
        empty_char='░',
        bar_template='%(label)s [%(bar)s] %(info)s',
        show_percent=True,
        show_eta=True
    ) as bar:
        for file in bar:
            # 다운로드 시뮬레이션
            time.sleep(0.5)
            click.echo(f'\n  ✓ {file} 완료')

if __name__ == '__main__':
    download()

### 확인 프롬프트 사용자에게 확인을 받고 싶을 때:

import click

@click.command()
@click.option('--force', is_flag=True, help='확인 없이 강제 실행')
def delete_all(force):
    """모든 데이터 삭제"""
    if not force:
        if not click.confirm('⚠️  정말로 모든 데이터를 삭제하시겠습니까?'):
            click.echo('❌ 작업이 취소되었습니다.')
            return
    
    click.echo('🗑️  데이터를 삭제하고 있습니다...')
    # 실제 삭제 로직
    click.echo('✅ 삭제 완료!')

if __name__ == '__main__':
    delete_all()

### 페이징(Paging) 긴 출력을 페이지 단위로 보여주기:

import click

@click.command()
def show_logs():
    """로그 보기"""
    logs = []
    for i in range(100):
        logs.append(f'[2024-01-{i%30+1:02d}] 로그 메시지 #{i+1}: 시스템 정상 작동 중')
    
    # 페이저를 통해 출력
    click.echo_via_pager('\n'.join(logs))

if __name__ == '__main__':
    show_logs()

## 🧪 테스트하기 CLI 도구도 테스트가 중요해요! Click은 테스트를 쉽게 할 수 있는 도구를 제공합니다. 🔬 ### CliRunner 사용하기

import click
from click.testing import CliRunner

# 테스트할 CLI 명령어
@click.command()
@click.option('--name', default='World', help='이름')
@click.option('--count', default=1, type=int, help='반복 횟수')
def hello(name, count):
    """인사 프로그램"""
    for _ in range(count):
        click.echo(f'Hello, {name}!')

# 테스트 코드
def test_hello_default():
    """기본값 테스트"""
    runner = CliRunner()
    result = runner.invoke(hello)
    
    assert result.exit_code == 0
    assert 'Hello, World!' in result.output

def test_hello_with_name():
    """이름 지정 테스트"""
    runner = CliRunner()
    result = runner.invoke(hello, ['--name', '철수'])
    
    assert result.exit_code == 0
    assert 'Hello, 철수!' in result.output

def test_hello_with_count():
    """반복 횟수 테스트"""
    runner = CliRunner()
    result = runner.invoke(hello, ['--name', '영희', '--count', '3'])
    
    assert result.exit_code == 0
    assert result.output.count('Hello, 영희!') == 3

if __name__ == '__main__':
    # 간단한 테스트 실행
    test_hello_default()
    test_hello_with_name()
    test_hello_with_count()
    print('✅ 모든 테스트 통과!')

### pytest와 함께 사용하기 실제 프로젝트에서는 pytest를 사용하는 게 좋아요:

# test_cli.py
import pytest
from click.testing import CliRunner
from myapp import cli

@pytest.fixture
def runner():
    """CliRunner 픽스처"""
    return CliRunner()

def test_basic_command(runner):
    """기본 명령어 테스트"""
    result = runner.invoke(cli, ['status'])
    assert result.exit_code == 0
    assert '정상' in result.output

def test_with_options(runner):
    """옵션 포함 테스트"""
    result = runner.invoke(cli, ['process', '--input', 'test.txt'])
    assert result.exit_code == 0

def test_error_handling(runner):
    """에러 처리 테스트"""
    result = runner.invoke(cli, ['process'])  # 필수 옵션 누락
    assert result.exit_code != 0
    assert 'Error' in result.output

def test_file_operations(runner):
    """파일 작업 테스트"""
    with runner.isolated_filesystem():
        # 임시 파일 생성
        with open('test.txt', 'w') as f:
            f.write('test content')
        
        # 명령어 실행
        result = runner.invoke(cli, ['convert', '--input', 'test.txt'])
        assert result.exit_code == 0
        
        # 결과 확인
        assert os.path.exists('output.txt')

### 환경 변수 테스트

import click
from click.testing import CliRunner

@click.command()
@click.option('--api-key', envvar='API_KEY', help='API 키')
def api_call(api_key):
    """API 호출"""
    if not api_key:
        click.echo('❌ API 키가 필요합니다.')
        raise click.Abort()
    
    click.echo(f'✅ API 키로 요청: {api_key[:4]}****')

def test_with_env_var():
    """환경 변수 테스트"""
    runner = CliRunner()
    
    # 환경 변수 설정
    result = runner.invoke(api_call, env={'API_KEY': 'test1234567890'})
    
    assert result.exit_code == 0
    assert 'test****' in result.output

def test_without_env_var():
    """환경 변수 없을 때 테스트"""
    runner = CliRunner()
    result = runner.invoke(api_call)
    
    assert result.exit_code != 0
    assert 'API 키가 필요합니다' in result.output

## 🎁 실전 예제: 완전한 CLI 도구 만들기 이제 배운 내용을 모두 활용해서 실용적인 CLI 도구를 만들어볼까요? 파일 관리 도구를 만들어보겠습니다! 🛠️

import click
import os
import shutil
from pathlib import Path
from datetime import datetime

@click.group()
@click.version_option(version='1.0.0')
def cli():
    """
    📁 파일 관리 도구 v1.0.0
    
    파일과 디렉토리를 쉽게 관리할 수 있는 CLI 도구입니다.
    """
    pass

@cli.command()
@click.argument('path', type=click.Path(exists=True))
@click.option('--recursive', '-r', is_flag=True, help='하위 디렉토리 포함')
@click.option('--human-readable', '-h', is_flag=True, help='사람이 읽기 쉬운 형식')
def size(path, recursive, human_readable):
    """디렉토리 크기 계산"""
    click.echo(f'📊 {path} 크기 계산 중...\n')
    
    total_size = 0
    file_count = 0
    
    if os.path.isfile(path):
        total_size = os.path.getsize(path)
        file_count = 1
    else:
        if recursive:
            for root, dirs, files in os.walk(path):
                for file in files:
                    filepath = os.path.join(root, file)
                    try:
                        total_size += os.path.getsize(filepath)
                        file_count += 1
                    except OSError:
                        pass
        else:
            for item in os.listdir(path):
                itempath = os.path.join(path, item)
                if os.path.isfile(itempath):
                    total_size += os.path.getsize(itempath)
                    file_count += 1
    
    if human_readable:
        size_str = format_size(total_size)
    else:
        size_str = f'{total_size:,} bytes'
    
    click.echo(f'📁 파일 수: {file_count:,}개')
    click.echo(f'💾 총 크기: {size_str}')

def format_size(bytes):
    """바이트를 사람이 읽기 쉬운 형식으로 변환"""
    for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
        if bytes < 1024.0:
            return f'{bytes:.2f} {unit}'
        bytes /= 1024.0
    return f'{bytes:.2f} PB'

@cli.command()
@click.argument('source', type=click.Path(exists=True))
@click.argument('dest', type=click.Path())
@click.option('--move', is_flag=True, help='복사 대신 이동')
@click.option('--force', '-f', is_flag=True, help='덮어쓰기 확인 안 함')
def copy(source, dest, move, force):
    """파일 또는 디렉토리 복사/이동"""
    action = '이동' if move else '복사'
    
    if os.path.exists(dest) and not force:
        if not click.confirm(f'⚠️  {dest}가 이미 존재합니다. 덮어쓰시겠습니까?'):
            click.echo('❌ 작업이 취소되었습니다.')
            return
    
    click.echo(f'📋 {action} 중: {source} → {dest}')
    
    try:
        if os.path.isfile(source):
            if move:
                shutil.move(source, dest)
            else:
                shutil.copy2(source, dest)
        else:
            if move:
                shutil.move(source, dest)
            else:
                shutil.copytree(source, dest, dirs_exist_ok=True)
        
        click.echo(click.style(f'✅ {action} 완료!', fg='green', bold=True))
    except Exception as e:
        click.echo(click.style(f'❌ 에러: {str(e)}', fg='red', bold=True))

@cli.command()
@click.argument('path', type=click.Path(exists=True))
@click.option('--ext', multiple=True, help='검색할 확장자 (예: .txt .py)')
@click.option('--name', help='파일명 패턴')
@click.option('--size-min', type=int, help='최소 크기 (bytes)')
@click.option('--size-max', type=int, help='최대 크기 (bytes)')
def find(path, ext, name, size_min, size_max):
    """파일 검색"""
    click.echo(f'🔍 {path}에서 파일 검색 중...\n')
    
    found_files = []
    
    for root, dirs, files in os.walk(path):
        for file in files:
            filepath = os.path.join(root, file)
            
            # 확장자 필터
            if ext and not any(file.endswith(e) for e in ext):
                continue
            
            # 이름 패턴 필터
            if name and name.lower() not in file.lower():
                continue
            
            # 크기 필터
            try:
                file_size = os.path.getsize(filepath)
                if size_min and file_size < size_min:
                    continue
                if size_max and file_size > size_max:
                    continue
            except OSError:
                continue
            
            found_files.append((filepath, file_size))
    
    if found_files:
        click.echo(f'📁 {len(found_files)}개 파일 발견:\n')
        
        for filepath, size in sorted(found_files):
            size_str = format_size(size)
            click.echo(f'  • {filepath} ({size_str})')
        
        total_size = sum(size for _, size in found_files)
        click.echo(f'\n💾 총 크기: {format_size(total_size)}')
    else:
        click.echo('❌ 조건에 맞는 파일을 찾을 수 없습니다.')

@cli.command()
@click.argument('path', type=click.Path(exists=True))
@click.option('--days', type=int, default=30, help='보관 기간 (일)')
@click.option('--dry-run', is_flag=True, help='실제 삭제 없이 시뮬레이션')
def cleanup(path, days, dry_run):
    """오래된 파일 정리"""
    from datetime import datetime, timedelta
    
    cutoff_date = datetime.now() - timedelta(days=days)
    
    click.echo(f'🗑️  {days}일 이상 된 파일 정리 중...')
    if dry_run:
        click.echo(click.style('(시뮬레이션 모드)', fg='yellow'))
    click.echo()
    
    deleted_files = []
    total_size = 0
    
    for root, dirs, files in os.walk(path):
        for file in files:
            filepath = os.path.join(root, file)
            
            try:
                mtime = datetime.fromtimestamp(os.path.getmtime(filepath))
                
                if mtime < cutoff_date:
                    size = os.path.getsize(filepath)
                    deleted_files.append((filepath, size, mtime))
                    total_size += size
                    
                    if not dry_run:
                        os.remove(filepath)
                        click.echo(f'  ✓ 삭제: {filepath}')
                    else:
                        click.echo(f'  • 삭제 예정: {filepath}')
            except OSError:
                pass
    
    click.echo()
    if deleted_files:
        click.echo(f'📊 통계:')
        click.echo(f'  • 파일 수: {len(deleted_files):,}개')
        click.echo(f'  • 확보 공간: {format_size(total_size)}')
        
        if dry_run:
            click.echo(click.style('\n💡 실제로 삭제하려면 --dry-run 옵션을 제거하세요.', fg='yellow'))
    else:
        click.echo('✅ 정리할 파일이 없습니다.')

@cli.command()
@click.argument('path', type=click.Path(exists=True))
def info(path):
    """파일/디렉토리 상세 정보"""
    click.echo(f'📋 {path} 정보\n')
    
    stat = os.stat(path)
    
    # 기본 정보
    if os.path.isfile(path):
        click.echo(f'타입: 📄 파일')
        click.echo(f'크기: {format_size(stat.st_size)}')
    else:
        click.echo(f'타입: 📁 디렉토리')
    
    # 시간 정보
    created = datetime.fromtimestamp(stat.st_ctime)
    modified = datetime.fromtimestamp(stat.st_mtime)
    accessed = datetime.fromtimestamp(stat.st_atime)
    
    click.echo(f'\n⏰ 시간 정보:')
    click.echo(f'  • 생성: {created.strftime("%Y-%m-%d %H:%M:%S")}')
    click.echo(f'  • 수정: {modified.strftime("%Y-%m-%d %H:%M:%S")}')
    click.echo(f'  • 접근: {accessed.strftime("%Y-%m-%d %H:%M:%S")}')
    
    # 권한 정보
    click.echo(f'\n🔒 권한:')
    click.echo(f'  • 읽기: {"✓" if os.access(path, os.R_OK) else "✗"}')
    click.echo(f'  • 쓰기: {"✓" if os.access(path, os.W_OK) else "✗"}')
    click.echo(f'  • 실행: {"✓" if os.access(path, os.X_OK) else "✗"}')

if __name__ == '__main__':
    cli()

이 도구는 다음과 같이 사용할 수 있어요:

# 디렉토리 크기 확인
python filemanager.py size /path/to/dir -r -h

# 파일 복사
python filemanager.py copy source.txt dest.txt

# 파일 검색
python filemanager.py find /path/to/dir --ext .py --ext .txt --size-min 1000

# 오래된 파일 정리 (시뮬레이션)
python filemanager.py cleanup /path/to/dir --days 90 --dry-run

# 파일 정보 보기
python filemanager.py info myfile.txt

# 도움말
python filemanager.py --help
python filemanager.py size --help

## 📦 패키징과 배포 만든 CLI 도구를 다른 사람들과 공유하고 싶다면 패키징이 필요해요! 🎁 ### setup.py 작성하기

from setuptools import setup, find_packages

setup(
    name='filemanager-cli',
    version='1.0.0',
    packages=find_packages(),
    include_package_data=True,
    install_requires=[
        'Click>=8.0',
    ],
    entry_points={
        'console_scripts': [
            'fm=filemanager:cli',
        ],
    },
    author='Your Name',
    author_email='your.email@example.com',
    description='파일 관리를 위한 CLI 도구',
    long_description=open('README.md').read(),
    long_description_content_type='text/markdown',
    url='https://github.com/yourusername/filemanager-cli',
    classifiers=[
        'Development Status :: 4 - Beta',
        'Intended Audience :: Developers',
        'License :: OSI Approved :: MIT License',
        'Programming Language :: Python :: 3',
        'Programming Language :: Python :: 3.8',
        'Programming Language :: Python :: 3.9',
        'Programming Language :: Python :: 3.10',
        'Programming Language :: Python :: 3.11',
    ],
    python_requires='>=3.8',
)

### pyproject.toml 사용하기 (최신 방식)

[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "filemanager-cli"
version = "1.0.0"
description = "파일 관리를 위한 CLI 도구"
readme = "README.md"
authors = [
    {name = "Your Name", email = "your.email@example.com"}
]
license = {text = "MIT"}
classifiers = [
    "Development Status :: 4 - Beta",
    "Intended Audience :: Developers",
    "License :: OSI Approved :: MIT License",
    "Programming Language :: Python :: 3",
    "Programming Language :: Python :: 3.8",
    "Programming Language :: Python :: 3.9",
    "Programming Language :: Python :: 3.10",
    "Programming Language :: Python :: 3.11",
]
requires-python = ">=3.8"
dependencies = [
    "click>=8.0",
]

[project.scripts]
fm = "filemanager:cli"

[project.urls]
Homepage = "https://github.com/yourusername/filemanager-cli"

### 설치 및 사용

# 개발 모드로 설치 (수정사항이 바로 반영됨)
pip install -e .

# 이제 어디서든 사용 가능!
fm size /path/to/dir
fm find . --ext .py
fm --help

# PyPI에 업로드
python -m build
twine upload dist/*

## 🚀 고급 기능들 Click의 더 강력한 기능들을 알아볼까요? 🎯 ### 커스텀 타입 만들기

import click

class EmailType(click.ParamType):
    """이메일 주소 타입"""
    name = 'email'
    
    def convert(self, value, param, ctx):
        if '@' not in value or '.' not in value.split('@')[1]:
            self.fail(f'{value}는 유효한 이메일 주소가 아닙니다.', param, ctx)
        return value.lower()

EMAIL = EmailType()

@click.command()
@click.option('--email', type=EMAIL, required=True, help='이메일 주소')
def send_mail(email):
    """이메일 발송"""
    click.echo(f'📧 {email}로 메일을 발송합니다...')
    click.echo('✅ 발송 완료!')

if __name__ == '__main__':
    send_mail()

### 환경 변수 활용

import click

@click.command()
@click.option('--api-key',
              envvar='API_KEY',
              required=True,
              help='API 키 (환경변수: API_KEY)')
@click.option('--endpoint',
              envvar='API_ENDPOINT',
              default='https://api.example.com',
              help='API 엔드포인트')
def api_request(api_key, endpoint):
    """API 요청"""
    click.echo(f'🌐 {endpoint}로 요청 중...')
    click.echo(f'🔑 API 키: {api_key[:4]}****')
    click.echo('✅ 요청 완료!')

if __name__ == '__main__':
    api_request()

사용 예시:

# 환경 변수 설정
export API_KEY=your_secret_key
export API_ENDPOINT=https://custom.api.com

# 실행 (환경 변수 사용)
python api.py

# 또는 직접 지정
python api.py --api-key your_key --endpoint https://api.example.com

### 콜백 함수 사용 옵션 값을 검증하거나 변환할 때 콜백을 사용할 수 있어요:

import click

def validate_port(ctx, param, value):
    """포트 번호 검증"""
    if value < 1 or value > 65535:
        raise click.BadParameter('포트는 1-65535 사이여야 합니다.')
    return value

def normalize_url(ctx, param, value):
    """URL 정규화"""
    if not value.startswith(('http://', 'https://')):
        value = 'https://' + value
    return value.rstrip('/')

@click.command()
@click.option('--port',
              type=int,
              default=8080,
              callback=validate_port,
              help='서버 포트')
@click.option('--url',
              callback=normalize_url,
              help='서버 URL')
def server(port, url):
    """서버 시작"""
    click.echo(f'🚀 서버 시작: {url}:{port}')

if __name__ == '__main__':
    server()

### 플러그인 시스템 Click으로 플러그인 가능한 CLI를 만들 수 있어요:

import click

class PluginCLI(click.MultiCommand):
    """플러그인 지원 CLI"""
    
    def list_commands(self, ctx):
        """사용 가능한 명령어 목록"""
        # 실제로는 플러그인 디렉토리를 스캔
        return ['plugin1', 'plugin2', 'plugin3']
    
    def get_command(self, ctx, name):
        """명령어 로드"""
        # 실제로는 플러그인 모듈을 동적으로 로드
        @click.command()
        def dynamic_command():
            click.echo(f'✨ {name} 플러그인 실행!')
        
        return dynamic_command

@click.command(cls=PluginCLI)
def cli():
    """플러그인 기반 CLI"""
    pass

if __name__ == '__main__':
    cli()

## 💡 베스트 프랙티스 Click으로 훌륭한 CLI 도구를 만들기 위한 팁들이에요! ⭐ ### 1. 명확한 명령어 이름 ### 2. 일관된 옵션 사용

# 공통 옵션은 일관되게 사용
--verbose / -v    # 상세 출력
--quiet / -q      # 최소 출력
--force / -f      # 확인 없이 실행
--dry-run         # 시뮬레이션
--help / -h       # 도움말
--version         # 버전 정보

### 3. 유용한 도움말 작성

@click.command()
@click.option('--format',
              type=click.Choice(['json', 'yaml', 'csv']),
              default='json',
              help='출력 형식. JSON은 기계 판독용, YAML은 사람 판독용, CSV는 스프레드시트용.')
@click.option('--output', '-o',
              type=click.File('w'),
              help='출력 파일 경로. 지정하지 않으면 표준 출력으로 출력됩니다.')
def export(format, output):
    """
    데이터를 다양한 형식으로 내보냅니다.
    
    예제:
    
        $ myapp export --format json -o data.json
        
        $ myapp export --format yaml > data.yaml
        
        $ myapp export --format csv | less
    """
    pass

### 4. 에러 처리

import click
import sys

@click.command()
@click.argument('filename', type=click.Path(exists=True))
def process(filename):
    """파일 처리"""
    try:
        with open(filename, 'r') as f:
            content = f.read()
        
        # 처리 로직
        result = content.upper()
        
        click.echo('✅ 처리 완료!')
        
    except PermissionError:
        click.echo(click.style('❌ 에러: 파일 접근 권한이 없습니다.', fg='red'), err=True)
        sys.exit(1)
    
    except UnicodeDecodeError:
        click.echo(click.style('❌ 에러: 파일 인코딩이 올바르지 않습니다.', fg='red'), err=True)
        sys.exit(1)
    
    except Exception as e:
        click.echo(click.style(f'❌ 예상치 못한 에러: {str(e)}', fg='red'), err=True)
        sys.exit(1)

if __name__ == '__main__':
    process()

### 5. 설정 파일 지원

import click
import json
from pathlib import Path

def load_config():
    """설정 파일 로드"""
    config_path = Path.home() / '.myapp' / 'config.json'
    
    if config_path.exists():
        with open(config_path) as f:
            return json.load(f)
    
    return {}

@click.command()
@click.option('--api-key', help='API 키')
@click.option('--endpoint', help='API 엔드포인트')
def api_call(api_key, endpoint):
    """API 호출"""
    config = load_config()
    
    # 명령줄 옵션이 우선, 없으면 설정 파일 사용
    api_key = api_key or config.get('api_key')
    endpoint = endpoint or config.get('endpoint', 'https://api.example.com')
    
    if not api_key:
        click.echo('❌ API 키가 필요합니다.')
        click.echo('명령줄 옵션으로 지정하거나 ~/.myapp/config.json에 설정하세요.')
        raise click.Abort()
    
    click.echo(f'🌐 {endpoint}로 요청 중...')
    click.echo('✅ 완료!')

if __name__ == '__main__':
    api_call()

### 6. 로깅 구현

import click
import logging
from pathlib import Path

def setup_logging(verbose):
    """로깅 설정"""
    log_dir = Path.home() / '.myapp' / 'logs'
    log_dir.mkdir(parents=True, exist_ok=True)
    
    log_file = log_dir / 'myapp.log'
    
    level = logging.DEBUG if verbose else logging.INFO
    
    logging.basicConfig(
        level=level,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        handlers=[
            logging.FileHandler(log_file),
            logging.StreamHandler()
        ]
    )
    
    return logging.getLogger('myapp')

@click.command()
@click.option('--verbose', '-v', is_flag=True, help='상세 로그 출력')
def process(verbose):
    """데이터 처리"""
    logger = setup_logging(verbose)
    
    logger.info('처리 시작')
    logger.debug('디버그 정보: 설정 로드 중...')
    
    # 작업 수행
    click.echo('✅ 처리 완료!')
    
    logger.info('처리 완료')

if __name__ == '__main__':
    process()

## 🌐 실제 사용 사례 Click으로 만들어진 유명한 프로젝트들을 살펴볼까요? 영감을 얻을 수 있을 거예요! 🌟 ### Flask 네, 맞아요! 유명한 웹 프레임워크 Flask의 CLI가 Click으로 만들어졌어요:

flask run
flask shell
flask db migrate
flask routes

Flask를 사용해본 적이 있다면 이미 Click을 경험한 거예요! 😊 ### Pipenv 파이썬 패키지 관리 도구 Pipenv도 Click을 사용해요:

pipenv install
pipenv shell
pipenv lock
pipenv graph

### AWS CLI v2 AWS의 공식 CLI 도구도 Click 기반이에요:

aws s3 ls
aws ec2 describe-instances
aws lambda invoke

## 🎓 학습 리소스 Click을 더 깊이 공부하고 싶다면 이런 자료들을 참고하세요! 📚 ### 공식 문서 • Click 공식 문서: https://click.palletsprojects.com/
• GitHub 저장소: https://github.com/pallets/click
• 예제 모음: https://github.com/pallets/click/tree/main/examples ### 추천 튜토리얼 • Real Python의 Click 가이드
• Python Click Tutorial (YouTube)
• Building CLI Applications with Click ### 커뮤니티 • Stack Overflow의 Click 태그
• Reddit의 r/Python 커뮤니티
• Discord의 Python 서버 ## 🎬 마무리하며 자, 여기까지 Click 라이브러리에 대해 알아봤어요! 정말 긴 여정이었죠? 😊

Click은 파이썬으로 CLI 도구를 만들 때 최고의 선택이에요. 간단한 스크립트부터 복잡한 명령줄 애플리케이션까지, Click은 모든 것을 우아하게 처리할 수 있답니다. 🎯

이제 여러분도 멋진 CLI 도구를 만들 수 있어요! 🚀

처음에는 간단한 도구부터 시작해보세요. 예를 들어:
• 자주 사용하는 명령어를 자동화하는 도구
• 파일을 정리하는 유틸리티
• 데이터를 변환하는 스크립트
• 개발 워크플로우를 돕는 도구

그리고 만든 도구를 재능넷 같은 플랫폼에서 공유하면서 다른 개발자들과 소통해보세요. 피드백을 받고 개선하다 보면 어느새 전문가가 되어 있을 거예요! 💪

Click으로 만든 CLI 도구는 여러분의 개발 생산성을 크게 향상시킬 거예요. 반복적인 작업을 자동화하고, 팀원들과 도구를 공유하고, 오픈소스 프로젝트에 기여할 수도 있죠! 🌟

이 글이 여러분의 Click 여정에 도움이 되었기를 바라요. 궁금한 점이 있다면 공식 문서를 참고하거나, 커뮤니티에 질문해보세요. 그리고 재능넷에서 다른 개발자들과 경험을 나누는 것도 잊지 마세요! 😊

행복한 코딩 되세요! 🎉✨