구분	장점	단점
보안성	악성 접근 차단, 기본 보호 제공	정상 프로그램도 차단 가능성
사용 편의성	GUI로 직관적인 설정 가능	세부 설정은 다소 복잡함
유연성	예외 규칙, 포트 제어 등 지원	잘못된 설정 시 네트워크 장애 발생

영어 숙어 속 감정의 온도차, threw over · chew over · stew over 완전 정리! 세 단어 모두 ‘over’가 들어있지만, 감정의 방향과 강도가 전혀 다릅니다. 이 글에서는 각 숙어의 핵심 의미, 실제 사용 맥락, 그리고 원어민이 느끼는 미묘한 뉘앙스까지 단계별로 정리해 드립니다. 😊

💡 알아두세요!
영어 숙어를 외울 때는 단순한 뜻보다는 ‘행동 이미지’를 떠올리면 훨씬 오래 기억됩니다. 예: throw → 버리다, chew → 되씹다, stew → 속 끓이다.

find out의 진짜 의미와 figure out과의 차이 영어를 공부하다 보면 ‘find out’과 ‘figure out’이 비슷하게 느껴지죠. 하지만 실제로는 의미와 사용 맥락이 전혀 다릅니다. 이 글에서는 두 표현의 뉘앙스 차이, 문법적 특징, 그리고 실전 예문까지 완벽히 정리해드립니다. 😊

💡 알아두세요!
find out은 ‘새로운 정보를 알게 되다’에 초점이 있고, 반복적인 시도 끝에 결과를 발견하는 느낌을 줍니다. 즉, 우연보다는 ‘노력의 결과’에 가깝습니다.

영어 속어 중 ‘bust my ass’와 ‘bust your ass’는 원어민 대화에서 자주 들리지만, 의미가 문맥에 따라 크게 달라집니다. 두 표현은 모두 비격식적인 속어로, ‘열심히 일하다’ 혹은 ‘위협하다’처럼 정반대의 뜻으로도 쓰이기 때문에 상황에 맞는 정확한 해석이 필요합니다. 이 글에서는 그 차이와 격식 있는 대체 표현을 정리했습니다.

1. Burst와 Bust의 의미 차이

영어 학습자들이 가장 먼저 혼동하는 부분은 burst와 bust의 의미적 차이입니다. burst는 내부의 압력으로 인해 터지는 것을 뜻하며, ‘풍선이 터지다’, ‘웃음보가 터지다’와 같은 자연스러운 폭발의 이미지를 갖습니다. 반면 bust는 외부의 힘에 의해 부서지거나 파괴되는 상황을 의미합니다. 예를 들어, 경찰이 문을 부수고 들어오는 상황이나, 회사가 파산하는 경우 go bust라고 표현합니다. 이처럼 ‘안에서 밖으로’ 터지는 burst와 ‘밖에서 안으로’ 깨지는 bust는 이미지적으로 반대되는 개념입니다.

2. Ass의 비유적 의미

ass는 기본적으로 ‘엉덩이’를 뜻하지만, 비유적 표현으로 다양한 의미를 가집니다. 일상 회화에서는 ‘멍청한 사람(He’s an ass)’, ‘끝내주는(badass)’, ‘빨리 움직여!(Move your ass!)’처럼 감정의 강도를 높이거나 비하의 뉘앙스를 전달하는 데 자주 사용됩니다. 다만 격식 있는 자리에서는 무례하게 들릴 수 있으므로, 대체로 butt 또는 완전한 표현인 work hard로 바꾸어 쓰는 것이 바람직합니다.

실제로 제가 해외 업무 중 한 동료가 “I worked my ass off on this project.”라고 말했을 때, 처음엔 거칠게 들렸지만, 문맥상 ‘열심히 했다’는 의미였음을 이해했습니다. 즉, 감정의 농도를 높이는 표현이지, 실제로 공격적인 의도는 없는 경우도 많습니다.

3. Bust my ass – ‘죽을힘을 다해 일하다’

bust my ass는 속어로 “뼈 빠지게 일하다”, “죽을힘을 다하다”를 뜻합니다. 감정적으로는 고생, 노력, 헌신의 의미를 강조하며, 주로 자신이 얼마나 수고했는지를 표현할 때 사용됩니다. 예: “I bust my ass every day to support my family.” → “가족을 부양하기 위해 매일같이 최선을 다한다.”

공식적인 자리에서는 “I worked extremely hard.”, “I put in a lot of effort.”처럼 대체하는 것이 좋습니다. 특히 비즈니스 이메일이나 발표에서는 속어를 그대로 옮기면 부적절하게 들릴 수 있습니다. 실제로 제가 프레젠테이션에서 “I bust my ass preparing this report.”라고 말했다가, 외국 동료가 웃으면서 “Maybe just say ‘I worked hard’ next time.”이라고 조언해준 경험이 있습니다.

4. Bust your ass – 문맥에 따라 달라지는 뜻

bust your ass는 문장의 주어에 따라 의미가 완전히 달라집니다. “You bust your ass”는 “너는 죽도록 일한다”는 긍정적 의미이고, “I’ll bust your ass”는 “혼내주겠다”, “응징하겠다”는 위협적 표현이 됩니다. 예: “Don’t make me bust your ass.” → “날 화나게 하지 마라.” 반대로 “You bust your ass every day.”는 “너 정말 열심히 일하잖아.”로 해석됩니다.

이러한 차이는 문맥과 주어의 위치에 따라 생기며, 잘못 해석하면 의미가 정반대로 바뀔 수 있습니다. 따라서 학습자는 반드시 문장의 구조와 분위기를 함께 파악해야 합니다. 저는 영화 대사 중 “Don’t make me bust your ass.”를 처음 들었을 때 ‘도와주다’로 오해했다가, 이후 ‘위협하다’의 의미라는 걸 알고 놀랐던 기억이 있습니다.

5. 공식적 대체 표현과 사용 주의

두 표현 모두 구어체에서는 자연스럽지만, 격식 있는 상황에서는 사용을 피해야 합니다. ‘열심히 일하다’의 뜻을 전하고 싶다면 work very hard, put in a lot of effort, ‘혼내주다’의 뉘앙스를 주고 싶다면 discipline 또는 take strong action으로 대체할 수 있습니다. 예: “Don’t make me bust your ass.” 대신 “Don’t push me too far.”라고 표현하면 훨씬 부드럽습니다.

언어는 단순한 번역을 넘어 ‘맥락의 예의’를 포함합니다. 실제 원어민조차 직장이나 공식 행사에서는 이러한 표현을 피하며, 친근한 구어체나 영화 대사에서만 사용하는 경향이 있습니다. 결국 중요한 것은 단어의 뜻보다도, 어떤 자리에서 어떤 어조로 사용하는가입니다.

💬 마무리

bust my ass와 bust your ass는 언뜻 비슷하지만, 주어와 문맥에 따라 ‘노력’ 또는 ‘위협’으로 완전히 달라집니다. 영어 학습에서는 의미뿐 아니라 사용 환경까지 이해하는 것이 중요합니다. 속어를 배울 때는 반드시 격식도(formality level)를 함께 확인하는 습관을 들이세요.

📚 자주 묻는 질문 (FAQ)

Q1. “bust my ass”는 무조건 비속어인가요?
→ 완전한 욕설은 아니지만, 비격식적인 속어입니다. 친한 관계나 구어체에서는 괜찮지만, 공식 자리에서는 피해야 합니다.

Q2. “bust your ass”는 실제 폭력을 의미하나요?
→ 대개는 ‘혼내주다’ 정도의 과장된 위협 표현입니다. 다만 공격적으로 들릴 수 있으므로 신중히 사용해야 합니다.

Q3. 업무 이메일에서는 어떤 표현이 적절한가요?
→ “I worked hard” 또는 “I put in a lot of effort”처럼 중립적이고 자연스러운 표현을 쓰는 것이 좋습니다.

Q4. “ass” 대신 사용할 수 있는 단어가 있나요?
→ 예의 바른 표현으로는 “butt” 혹은 단순히 생략하여 “I worked hard.”로 표현할 수 있습니다.

Q5. 원어민도 실제로 이 표현을 자주 쓰나요?
→ 네, 영화, 드라마, 일상 대화에서는 매우 흔합니다. 다만 비즈니스나 공식 문서에서는 거의 사용하지 않습니다.

 bust my ass, bust your ass, 영어 속어, 비격식 표현, 영어 대체 표현, work hard, effort, 영어 회화, 공식 영어, formality

2025.09.07 – [언어/영어] – Be my guest 손님이 되세요? 이런 뜻 아니죠~

수능 영어 독해 필수 다의어 strip의 뜻과 예문

‘cling’에서 시작하는 5가지 손의 동사 완전 정리 — 감정과 힘의 미묘한 영어 어감 차이 영어 단어 cling, grasp, clutch, clench, clinch는 모두 ‘붙잡다’라는 공통된 뿌리를 가지고 있지만, 손끝의 힘, 감정의 농도, 그리고 상황의 긴박함에 따라 그 뉘앙스는 전혀 다릅니다. 이번 글에서는 각 단어의 실제 이미지와 사용 예시를 통해 자연스러운 영어 감각을 익혀봅니다.

💡 알아두세요!
Cling은 물리적으로 매달리는 것뿐 아니라 감정적으로 ‘의존하다’, ‘집착하다’의 의미로도 자주 쓰입니다. “Don’t cling to something just because it’s familiar.” (익숙하다는 이유로 매달리지 마세요.)

‘add’ 하나로 영어 감 잡기! 단순한 ‘더하다’에서 시작해 add up, add to, add insult to injury까지, 일상 회화와 뉴스에서 자주 등장하는 ‘add’ 표현들을 총정리합니다. 짧은 단어지만 풍부한 의미 확장을 통해 영어 감각을 키워보세요.

💡 알아두세요!
‘add’는 기본적으로 A + B 구조를 갖지만, add to, add up, add on처럼 전치사에 따라 의미가 크게 변합니다.

‘allow’의 두 얼굴, 어원으로 완전히 이해하기 영어 단어 allow는 단순히 ‘허락하다’ 이상의 의미를 갖습니다. 두 가지 서로 다른 라틴어 어원에서 파생된 이 단어는 ‘배정하다’와 ‘승인하다’라는 두 흐름이 만나 현재의 다양한 쓰임을 만들어냈습니다. 이 글에서는 그 어원과 의미 차이, 문법적 활용을 자세히 정리합니다.

💡 알아두세요!
어원 분석은 단순한 암기보다 강력합니다. allow의 두 뿌리를 이해하면 allowance(배정된 돈), allow for(감안하다), be allowed to(허락되다)가 왜 서로 다른 뉘앙스를 가지는지 명확히 구분할 수 있습니다.

아이폰 모바일 신분증 등록 완벽 가이드! 이제 지갑 없이도 신분증을 제시할 수 있는 시대가 열렸습니다. IC 신분증 준비부터 토스, 모바일 신분증 앱 등록 방법까지 단계별로 친절히 설명합니다. 누구나 쉽게 따라 할 수 있는 실전 가이드입니다.

💡 알아두세요!
IC 신분증은 NFC를 활용해 스마트폰이 직접 인식하므로, 아이폰 8 이상 기기가 필요합니다.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
X(Twitter) → Notion 자동 파이프라인 (macOS, 최종판)
- 창 열림 + 로그인 대기(콘솔 Enter) 후 수집 시작
- macOS Chrome 프로필 자동 감지 + 잠금 시 임시 프로필 복제(B 방안)
- webdriver_manager의 THIRD_PARTY_NOTICES.chromedriver 경로 보정
- 무한 스크롤로 TARGET_COUNT 까지 수집
- 이미지/동영상 다운로드 → 5MiB 이하 자동 압축 → Notion 업로드(새 File Upload API)
- DB 스키마 유연 적응: Title 자동 탐색, 기타 속성은 있으면 매핑/없으면 생략
- Media(files) 없으면 생성 시도 → 실패 시 file 블록(children)로 첨부
- 중복 방지: 페이지 재활용, 동일 파일명 재업로드 방지
- 업로드 성공 파일은 즉시 로컬 삭제
"""

import os, re, csv, time, stat, json, logging, io, subprocess, shutil, tempfile
from pathlib import Path
from typing import Dict, Any, List, Optional, Tuple

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
from urllib.parse import urlparse, parse_qsl, urlencode, urlunparse

from PIL import Image

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.by import By
from selenium.common.exceptions import SessionNotCreatedException, WebDriverException
from webdriver_manager.chrome import ChromeDriverManager
import yt_dlp

# ===================== 설정 =====================
ACCOUNT       = "수집대상"      # 수집 대상 X 계정
TARGET_COUNT  = 8000                  # 원하는 수집 개수
MAX_SCROLL    = 100000                 # 최대 스크롤 시도
SCROLL_PAUSE  = 7.5                  # 스크롤 간 대기(안정성)
HEADLESS      = False                # 창 열림 권장(True면 로그인 대기 비활성)
WAIT_FOR_LOGIN= True                 # 창 뜬 뒤 로그인하고 콘솔 Enter로 시작

OUT_DIR       = Path("./NatureIsAmazing_v3")

# Notion (개인용, 하드코딩 요청 반영)
NOTION_API_KEY         = "노션API"
NOTION_DATABASE_ID_RAW = "노션DP"  # 하이픈 없어도 허용
NOTION_VERSION         = "2022-06-28"

# 선택: X 로그인 쿠키(Netscape 형식, yt-dlp용)
COOKIES_FILE = ""  # 예) "/Users/아이디(영문이름)/cookies_twitter.txt"

UA = ("Mozilla/5.0 (Macintosh; Intel Mac OS X 13_5) AppleWebKit/537.36 "
      "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")

MAX_UPLOAD_BYTES = 5 * 1024 * 1024  # 5 MiB

logging.basicConfig(level=logging.INFO,
                    format="%(asctime)s | %(levelname)s | %(message)s",
                    datefmt="%H:%M:%S")

# ===================== 공통 유틸 =====================
def ensure_executable(path: str):
    if not os.access(path, os.X_OK):
        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR |
                       stat.S_IRGRP | stat.S_IXGRP |
                       stat.S_IROTH | stat.S_IXOTH)

def build_http_session() -> requests.Session:
    s = requests.Session()
    retries = Retry(total=5, connect=5, read=5, backoff_factor=0.6,
                    status_forcelist=(429,500,502,503,504),
                    allowed_methods=["GET","HEAD","OPTIONS"])
    s.headers.update({"User-Agent": UA, "Accept": "*/*"})
    s.mount("http://", HTTPAdapter(max_retries=retries))
    s.mount("https://", HTTPAdapter(max_retries=retries))
    return s

def normalize_x_url(u: str) -> str:
    return u.replace("x.com", "twitter.com")

def force_orig(url: str) -> str:
    if "twimg.com/media" not in url:
        return url
    parts = list(urlparse(url))
    qs = dict(parse_qsl(parts[4]))
    qs["name"] = "orig"
    parts[4] = urlencode(qs)
    return urlunparse(parts)

def hyphenate_uuid(s: str) -> str:
    s = re.sub(r"[^0-9a-fA-F]", "", s)
    return f"{s[0:8]}-{s[8:12]}-{s[12:16]}-{s[16:20]}-{s[20:32]}" if len(s)==32 else s

NOTION_DATABASE_ID = hyphenate_uuid(NOTION_DATABASE_ID_RAW)

# ===================== macOS Chrome 프로필 감지/복제 =====================
def _profile_locked(profile_path: Path) -> bool:
    for name in ("SingletonLock","SingletonCookie","SingletonSocket"):
        if (profile_path / name).exists():
            return True
    return False

def _make_ephemeral_profile(base_dir: Path, profile_dir: str) -> Tuple[str,str]:
    """
    원본 프로필에서 핵심 데이터만 복사하여 임시 user-data-dir 생성.
    큰 캐시류는 제외해 충돌 최소화.
    """
    src = base_dir / profile_dir
    tmp_root = Path(tempfile.mkdtemp(prefix="chrome-epi-"))
    dst = tmp_root / "Default"
    dst.mkdir(parents=True, exist_ok=True)

    whitelist = [
        "Cookies","Cookies-journal","Network","Preferences","Secure Preferences",
        "Local Storage","History","Favicons","Visited Links","Bookmarks","Session Storage"
    ]
    blacklist = {"Cache","Code Cache","GPUCache","Service Worker","ShaderCache","GrShaderCache"}

    def _copy_entry(name: str):
        s = src / name
        d = dst / name
        if not s.exists(): return
        if s.is_dir():
            if name in blacklist: return
            shutil.copytree(s, d, dirs_exist_ok=True)
        else:
            try: shutil.copy2(s, d)
            except Exception: pass

    for entry in whitelist: _copy_entry(entry)
    for name in os.listdir(src):
        if name in whitelist or name in blacklist: continue
        sp = src / name
        dp = dst / name
        try:
            if sp.is_file() and sp.stat().st_size <= 5*1024*1024:
                shutil.copy2(sp, dp)
        except Exception:
            pass

    return str(tmp_root), "Default"

def find_chrome_profile_on_macos() -> Tuple[Optional[str], Optional[str]]:
    home = Path.home()
    base = home / "Library" / "Application Support" / "Google" / "Chrome"
    local_state = base / "Local State"
    try:
        if local_state.is_file():
            data = json.loads(local_state.read_text(encoding="utf-8"))
            last_used = data.get("profile", {}).get("last_used")
            if last_used and (base / last_used).is_dir():
                return str(base), last_used
    except Exception:
        pass
    for name in ["Default"]+[f"Profile {i}" for i in range(1,12)]:
        if (base / name).is_dir():
            return str(base), name
    return None, None

# ===================== 압축기 =====================
def compress_image_to_limit(src: Path, dst: Path, max_bytes: int = MAX_UPLOAD_BYTES) -> bool:
    try:
        img = Image.open(src).convert("RGB")
    except Exception as e:
        logging.error(f"이미지 열기 실패: {src} -> {e}")
        return False

    def resize(img, max_side):
        w, h = img.size
        if max(w,h) <= max_side: return img
        ratio = max_side / max(w,h)
        return img.resize((int(w*ratio), int(h*ratio)), Image.LANCZOS)

    for ms in [1600, 1400, 1200, 1000, 800, 640, 560, 480]:
        test = resize(img, ms)
        for q in [85,80,72,65,57,50,42,35,30,25]:
            buf = io.BytesIO()
            test.save(buf, format="JPEG", quality=q, optimize=True, progressive=True)
            data = buf.getvalue()
            if len(data) <= max_bytes:
                dst.write_bytes(data); return True
    buf = io.BytesIO()
    resize(img, 432).save(buf, format="JPEG", quality=24, optimize=True, progressive=True)
    dst.write_bytes(buf.getvalue())
    return dst.stat().st_size <= max_bytes

def _run_ffmpeg(args: List[str]) -> bool:
    try:
        res = subprocess.run(args, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=False)
        return res.returncode == 0
    except Exception:
        return False

def compress_video_to_limit(src: Path, dst: Path, max_bytes: int = MAX_UPLOAD_BYTES) -> bool:
    steps = [
        ("scale='min(720,iw)':-2", 28, 64),
        ("scale='min(640,iw)':-2", 30, 56),
        ("scale='min(540,iw)':-2", 32, 48),
        ("scale='min(480,iw)':-2", 35, 40),
    ]
    for vf, crf, a_kbps in steps:
        args = ["ffmpeg","-y","-i",str(src),
                "-vf",vf,"-c:v","libx264","-preset","veryfast","-crf",str(crf),
                "-c:a","aac","-b:a",f"{a_kbps}k","-movflags","+faststart",
                "-fs",str(max_bytes-1024), str(dst)]
        if _run_ffmpeg(args) and dst.exists() and dst.stat().st_size <= max_bytes:
            return True
    args = ["ffmpeg","-y","-i",str(src),
            "-vf","scale='min(432,iw)':-2","-c:v","libx264","-preset","veryfast","-crf","38",
            "-c:a","aac","-b:a","40k","-movflags","+faststart","-fs",str(max_bytes-1024), str(dst)]
    return _run_ffmpeg(args) and dst.exists() and dst.stat().st_size <= max_bytes

# ===================== Selenium / Driver (안정화 리트라이) =====================
def _system_chrome_binary() -> Optional[str]:
    candidates = [
        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
        str(Path.home() / "Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
    ]
    for c in candidates:
        if os.path.exists(c):
            return c
    return None

def _resolve_chromedriver_path(raw_path: str) -> str:
    path = raw_path
    if os.path.basename(path) == "THIRD_PARTY_NOTICES.chromedriver":
        d = os.path.dirname(path)
        for f in os.listdir(d):
            p = os.path.join(d, f)
            if f.startswith("chromedriver") and os.path.isfile(p):
                path = p; break
    if not os.path.isfile(path) or not os.access(path, os.X_OK):
        d = os.path.dirname(path)
        for f in os.listdir(d):
            p = os.path.join(d, f)
            if f.startswith("chromedriver") and os.path.isfile(p) and os.access(p, os.X_OK):
                path = p; break
    ensure_executable(path)
    return path

def _base_options(headless: bool) -> Options:
    opts = Options()
    # 공통 옵션
    opts.add_argument("--no-sandbox")
    opts.add_argument("--disable-dev-shm-usage")
    opts.add_argument("--disable-gpu")
    opts.add_argument("--window-size=1280,2400")
    opts.add_argument("--disable-notifications")
    opts.add_argument("--disable-extensions")
    opts.add_argument("--mute-audio")
    opts.add_argument("--log-level=3")
    opts.add_argument(f"--user-agent={UA}")
    if headless:
        opts.add_argument("--headless=new")
        opts.add_argument("--disable-software-rasterizer")
        opts.add_argument("--disable-features=VizDisplayCompositor")
    # 시스템 Chrome 바이너리 지정
    sys_bin = _system_chrome_binary()
    if sys_bin:
        opts.binary_location = sys_bin
        logging.info(f"Using system Chrome binary: {sys_bin}")
    else:
        logging.warning("System Chrome binary not found. Relying on default.")
    return opts

def _start_driver_with(opts: Options) -> webdriver.Chrome:
    raw = ChromeDriverManager().install()
    path = _resolve_chromedriver_path(raw)
    return webdriver.Chrome(service=Service(path), options=opts)

def setup_driver(headless: bool = False):
    """
    부팅 전략(순차 재시도):
    1) 시스템 프로필 사용
    2) 시스템 프로필 잠금/충돌 → 임시 복제 프로필 사용
    3) 프로필 없이 기본 실행
    4) headless 최소 옵션
    """
    # 1) 시스템 프로필 시도
    base, prof = find_chrome_profile_on_macos()
    if base and prof:
        profile_path = Path(base) / prof
        opts = _base_options(headless=headless)
        if _profile_locked(profile_path):
            logging.info("Profile locked → try ephemeral clone")
        else:
            opts.add_argument(f"--user-data-dir={base}")
            opts.add_argument(f"--profile-directory={prof}")
            try:
                logging.info(f"Launching Chrome with profile: {prof}")
                return _start_driver_with(opts)
            except (SessionNotCreatedException, WebDriverException) as e:
                logging.warning(f"Profile launch failed: {e}")

        # 2) 임시 복제 프로필
        try:
            epi_dir, epi_prof = _make_ephemeral_profile(Path(base), prof)
            opts = _base_options(headless=headless)
            opts.add_argument(f"--user-data-dir={epi_dir}")
            opts.add_argument(f"--profile-directory={epi_prof}")
            logging.info("Launching Chrome with ephemeral profile")
            return _start_driver_with(opts)
        except (SessionNotCreatedException, WebDriverException) as e:
            logging.warning(f"Ephemeral profile launch failed: {e}")

    # 3) 프로필 없이
    try:
        opts = _base_options(headless=headless)
        logging.info("Launching Chrome without user profile")
        return _start_driver_with(opts)
    except (SessionNotCreatedException, WebDriverException) as e:
        logging.warning(f"No-profile launch failed: {e}")

    # 4) 최후: headless 최소 옵션
    try:
        opts = _base_options(headless=True)
        logging.info("Launching Chrome headless (fallback)")
        return _start_driver_with(opts)
    except Exception as e:
        logging.error(f"All launch strategies failed: {e}")
        raise

# ===================== 로그인 대기 =====================
def wait_for_login_and_keypress(driver, account: str) -> bool:
    try:
        # 대상 프로필 페이지로 포커스
        target = f"https://x.com/{account}"
        if "x.com" not in driver.current_url and "twitter.com" not in driver.current_url:
            driver.get(target)
            time.sleep(2)

        print("\n==============================================")
        print(" 로그인 후 계속 진행 안내")
        print("----------------------------------------------")
        print(" 1) 열린 Chrome 창에서 X(Twitter)에 로그인하세요.")
        print(" 2) 프로필/타임라인이 정상 로드되는지 확인하세요.")
        print(" 3) 여기 콘솔에서 Enter를 누르면 스크랩을 시작합니다.")
        print("    (s 입력 후 Enter: 즉시 시작)")
        print("==============================================\n")
        _ = input("로그인 완료 후 Enter(또는 s 입력 후 Enter)를 눌러 계속: ").strip().lower()
        return True
    except Exception as e:
        logging.warning(f"로그인 대기 중 경고: {e}")
        return True

# ===================== 스크랩 =====================
def download_file(session: requests.Session, url: str, dest: Path) -> bool:
    try:
        tmp = dest.with_suffix(dest.suffix + ".part")
        with session.get(url, stream=True, timeout=30) as r:
            r.raise_for_status()
            with open(tmp, "wb") as f:
                for chunk in r.iter_content(8192):
                    if chunk: f.write(chunk)
        os.replace(tmp, dest)
        return True
    except Exception as e:
        logging.warning(f"이미지 다운로드 실패: {url} -> {e}")
        return False

def find_video_links(card) -> Optional[str]:
    links = [a.get_attribute("href") for a in card.find_elements(By.TAG_NAME, "a")]
    for l in links:
        if l and ("/video/" in l or "/i/status/" in l or "/status/" in l):
            return l
    return None

def download_video(tweet_url: str, dest: Path) -> bool:
    try:
        url = normalize_x_url(tweet_url)
        ydl_opts = {
            "quiet": True,
            "no_warnings": True,
            "format": "bv*[ext=mp4]+ba[ext=m4a]/b[ext=mp4]/bv*+ba/b",
            "merge_output_format": "mp4",
            "outtmpl": str(dest),
            "retries": 5,
            "fragment_retries": 10,
            "socket_timeout": 20,
            "user_agent": UA,
            "geo_bypass": True,
            "concurrent_fragment_downloads": 3,
        }
        if COOKIES_FILE and Path(COOKIES_FILE).exists():
            ydl_opts["cookiefile"] = COOKIES_FILE
        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
            ydl.download([url])
        return True
    except Exception as e:
        logging.warning(f"영상 다운로드 실패: {url} -> {e}")
        return False

def scrape(account: str, out_dir: Path, max_scroll: int, scroll_pause: float,
           headless: bool, target_count: int = 100) -> Dict[str, Any]:
    out_dir.mkdir(exist_ok=True)
    media_dir = out_dir / "media"; media_dir.mkdir(exist_ok=True)
    csv_path = out_dir / "tweets.csv"

    driver = setup_driver(headless=headless)
    driver.get(f"https://x.com/{account}")
    time.sleep(5)

    # 로그인 대기
    if WAIT_FOR_LOGIN and not headless:
        if not wait_for_login_and_keypress(driver, account):
            logging.error("로그인 대기 실패"); driver.quit()
            return {"tweets": {}, "csv": csv_path, "media_dir": media_dir, "account": account}

    tweets: Dict[str, Dict[str, Any]] = {}
    last_height = driver.execute_script("return document.body.scrollHeight")
    stalls, stall_limit = 0, 12
    session = build_http_session()

    logging.info(f"@{account} 수집 시작… (목표 {target_count}개)")
    for _ in range(max_scroll):
        cards = driver.find_elements(By.XPATH, "//article[@data-testid='tweet']")
        new_count = 0
        for c in cards:
            try:
                link = c.find_element(By.XPATH, ".//a[contains(@href,'status')]")
                tid = link.get_attribute("href").split("/")[-1]
                if not tid or not tid.isdigit() or tid in tweets:
                    continue
                text = c.text.replace("\n", " ")
                imgs = [force_orig(i.get_attribute("src")) for i in c.find_elements(By.XPATH, ".//img[contains(@src,'twimg.com/media')]")]
                vids = [v.get_attribute("src") for v in c.find_elements(By.XPATH, ".//video") if v.get_attribute("src")]
                orig_video = find_video_links(c)
                tweets[tid] = {"id": tid, "text": text, "images": imgs, "videos": vids, "orig_video": orig_video}
                new_count += 1
            except Exception:
                pass

        if len(tweets) >= target_count:
            logging.info(f"목표 {target_count}개 달성, 스크랩 종료"); break

        # 스크롤 지그재그
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
        time.sleep(scroll_pause)
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight*0.85);")
        time.sleep(scroll_pause)

        new_height = driver.execute_script("return document.body.scrollHeight")
        if new_height == last_height and new_count == 0:
            stalls += 1
            if stalls >= stall_limit:
                logging.info("더 이상 컨텐츠 로드 없음 → 종료"); break
        else:
            stalls = 0
        last_height = new_height

    driver.quit()
    logging.info(f"트윗 {len(tweets)}개 수집 완료")

    # CSV
    with open(csv_path, "w", newline="", encoding="utf-8") as f:
        w = csv.writer(f)
        w.writerow(["id", "text", "image_count", "video_count", "orig_video"])
        for t in tweets.values():
            w.writerow([t["id"], t["text"], len(t["images"]), len(t["videos"]), t["orig_video"]])
    logging.info(f"CSV 저장: {csv_path}")

    # 미디어 다운로드
    logging.info("미디어 다운로드…")
    for tid, t in tweets.items():
        tweet_url = normalize_x_url(t.get("orig_video") or f"https://x.com/{account}/status/{tid}")
        for idx, m in enumerate(t["images"], 1):
            dest = media_dir / f"{tid}_img{idx}.jpg"
            if not dest.exists():
                download_file(session, m, dest)
        if bool(t.get("videos")) or bool(t.get("orig_video")):
            dest = media_dir / f"{tid}_video.mp4"
            if not dest.exists():
                download_video(tweet_url, dest)

    logging.info(f"미디어 저장 완료: {media_dir}")
    return {"tweets": tweets, "csv": csv_path, "media_dir": media_dir, "account": account}

# ===================== Notion (유연 매핑) =====================
def notion_headers() -> Dict[str, str]:
    h = {"Authorization": f"Bearer {NOTION_API_KEY}",
         "Content-Type": "application/json"}
    if NOTION_VERSION: h["Notion-Version"] = NOTION_VERSION
    return h

def notion_get_db() -> Dict[str, Any]:
    r = requests.get(f"https://api.notion.com/v1/databases/{NOTION_DATABASE_ID}",
                     headers=notion_headers(), timeout=30)
    r.raise_for_status(); return r.json()

def find_title_prop(db: Dict[str, Any]) -> str:
    for name, meta in db.get("properties", {}).items():
        if meta.get("type") == "title": return name
    raise RuntimeError("이 DB에는 Title 속성이 없습니다. (제목 속성 1개 필요)")

def map_optional_props(db: Dict[str, Any]) -> Dict[str, Optional[str]]:
    props = db.get("properties", {})
    def norm(s): return re.sub(r"[\s_]+","",s.lower())
    candidates = {
        "text": ["text","tweettext","본문","내용"],
        "image_count": ["imagecount","images","imgcount","이미지개수","이미지수"],
        "video_count": ["videocount","videos","vidcount","동영상개수","비디오개수"],
        "tweet_url": ["tweeturl","url","링크","원문","원본url"],
        "media": ["media","files","attachments","첨부","파일"],
    }
    found = {"text":None,"image_count":None,"video_count":None,"tweet_url":None,"media":None}
    for name, meta in props.items():
        t = meta.get("type"); n = norm(name)
        if t=="rich_text" and found["text"] is None and (n in candidates["text"]): found["text"]=name
        if t=="number"    and found["image_count"] is None and (n in candidates["image_count"]): found["image_count"]=name
        if t=="number"    and found["video_count"] is None and (n in candidates["video_count"]): found["video_count"]=name
        if t=="url"       and found["tweet_url"] is None and (n in candidates["tweet_url"]): found["tweet_url"]=name
        if t=="files"     and found["media"] is None and (n in candidates["media"]): found["media"]=name
    # 타입 기반 폴백
    if not found["text"]:
        for n,m in props.items():
            if m.get("type")=="rich_text": found["text"]=n; break
    if not found["tweet_url"]:
        for n,m in props.items():
            if m.get("type")=="url": found["tweet_url"]=n; break
    if not found["media"]:
        for n,m in props.items():
            if m.get("type")=="files": found["media"]=n; break
    if not found["image_count"]:
        for n,m in props.items():
            if m.get("type")=="number": found["image_count"]=n; break
    if not found["video_count"]:
        for n,m in props.items():
            if m.get("type")=="number" and n!=found["image_count"]: found["video_count"]=n; break
    return found

def ensure_media_property(db: Dict[str, Any]) -> Optional[str]:
    for name, meta in db.get("properties", {}).items():
        if meta.get("type")=="files": return name
    patch = {"properties":{"Media":{"name":"Media","type":"files","files":{}}}}
    r = requests.patch(f"https://api.notion.com/v1/databases/{NOTION_DATABASE_ID}",
                       headers=notion_headers(), json=patch, timeout=30)
    if r.status_code in (200,202): return "Media"
    logging.warning(f"DB files 속성 생성 실패: {r.status_code} {r.text}")
    return None

def notion_query_by_title(title_prop: str, value: str) -> Optional[str]:
    payload = {"filter":{"property":title_prop,"title":{"equals":value}},"page_size":1}
    r = requests.post(f"https://api.notion.com/v1/databases/{NOTION_DATABASE_ID}/query",
                      headers=notion_headers(), json=payload, timeout=30)
    r.raise_for_status(); res = r.json().get("results", [])
    return res[0]["id"] if res else None

def notion_create_page(row: Dict[str, Any], title_prop: str, opt: Dict[str, Optional[str]]) -> str:
    props: Dict[str, Any] = {title_prop: {"title":[{"text":{"content":row["id"]}}]}}
    if opt["text"]:
        txt = (row.get("text") or "")[:2000]
        props[opt["text"]] = {"rich_text":[{"text":{"content":txt}}]} if txt else {"rich_text":[]}
    if opt["image_count"]:
        props[opt["image_count"]] = {"number": len(row.get("images", []))}
    if opt["video_count"]:
        props[opt["video_count"]] = {"number": len(row.get("videos", []))}
    if opt["tweet_url"]:
        props[opt["tweet_url"]] = {"url": row["tweet_url"]}

    payload = {"parent":{"database_id":NOTION_DATABASE_ID},
               "properties": props,
               "children":[{"object":"block","type":"bookmark","bookmark":{"url":row["tweet_url"]}}]}
    r = requests.post("https://api.notion.com/v1/pages", headers=notion_headers(), json=payload, timeout=30)
    if r.status_code >= 400:
        logging.error(f"페이지 생성 실패: {r.status_code} {r.text}\nPayload: {payload}")
    r.raise_for_status()
    return r.json()["id"]

def notion_get_page_media_names(page_id: str, media_prop: Optional[str]) -> List[str]:
    if not media_prop: return []
    r = requests.get(f"https://api.notion.com/v1/pages/{page_id}", headers=notion_headers(), timeout=30)
    r.raise_for_status()
    items = r.json().get("properties", {}).get(media_prop, {}).get("files", [])
    return [i.get("name") for i in items if i.get("name")]

# --- File Upload API ---
def mime_from_suffix(p: Path) -> str:
    ext = p.suffix.lower()
    if ext in [".jpg",".jpeg"]: return "image/jpeg"
    if ext == ".png": return "image/png"
    if ext == ".gif": return "image/gif"
    if ext == ".mp4": return "video/mp4"
    return "application/octet-stream"

def notion_create_file_upload(name: str, mime: str) -> Dict[str, Any]:
    r = requests.post("https://api.notion.com/v1/file_uploads",
                      headers=notion_headers(),
                      json={"file_name": name, "file_mime_type": mime}, timeout=60)
    r.raise_for_status(); return r.json()

def notion_send_file_upload(file_upload_id: str, filepath: Path):
    headers = {k:v for k,v in notion_headers().items() if k!="Content-Type"}
    with open(filepath, "rb") as fh:
        r = requests.post(f"https://api.notion.com/v1/file_uploads/{file_upload_id}/send",
                          headers=headers, files={"file": (filepath.name, fh)}, timeout=600)
    r.raise_for_status(); return r.json()

def as_uploaded_file_obj(file_upload_id: str, name: str) -> Dict[str, Any]:
    return {"name": name, "type": "file_upload", "file_upload": {"id": file_upload_id}}

def notion_update_media_property(page_id: str, media_prop: str, files: List[Dict[str, Any]]):
    payload = {"properties": {media_prop: {"files": files}}}
    r = requests.patch(f"https://api.notion.com/v1/pages/{page_id}",
                       headers=notion_headers(), json=payload, timeout=60)
    if r.status_code >= 400:
        logging.error(f"Media 속성 업데이트 실패: {r.status_code} {r.text}\nPayload: {payload}")
    r.raise_for_status()

def notion_append_file_blocks(page_id: str, files: List[Dict[str, Any]]):
    children = []
    for f in files:
        children.append({"object":"block","type":"file",
                         "file":{"type":"file_upload","file_upload":{"file_upload_id": f["file_upload"]["id"]}}})
    r = requests.patch(f"https://api.notion.com/v1/blocks/{page_id}/children",
                       headers=notion_headers(), json={"children": children}, timeout=60)
    if r.status_code >= 400:
        logging.error(f"파일 블록 첨부 실패: {r.status_code} {r.text}")
    r.raise_for_status()

# ===================== 파이프라인 =====================
def run_pipeline(account: str, out_dir: Path, target_count: int, max_scroll: int, headless: bool):
    result = scrape(account, out_dir, max_scroll, SCROLL_PAUSE, headless, target_count=target_count)
    tweets = result["tweets"]; media_dir: Path = result["media_dir"]

    if not (NOTION_API_KEY and NOTION_DATABASE_ID):
        logging.error("NOTION_API_KEY/NOTION_DATABASE_ID 필요"); return

    db = notion_get_db()
    title_prop = find_title_prop(db)
    opt_props  = map_optional_props(db)
    if not opt_props["media"]:
        created = ensure_media_property(db)
        if created: opt_props["media"] = created

    for tid, t in tweets.items():
        row = {
            "id": tid,
            "text": t.get("text",""),
            "images": t.get("images",[]),
            "videos": t.get("videos",[]),
            "tweet_url": normalize_x_url(t.get("orig_video") or f"https://x.com/{account}/status/{tid}"),
        }

        page_id = notion_query_by_title(title_prop, row["id"])
        if not page_id:
            try:
                page_id = notion_create_page(row, title_prop, opt_props)
            except requests.HTTPError as e:
                logging.error(f"[{tid}] 페이지 생성 실패 → 스킵: {e}")
                continue
        time.sleep(0.25)

        existing_names = set()
        if opt_props["media"]:
            try:
                existing_names = set(notion_get_page_media_names(page_id, opt_props["media"]))
            except Exception as e:
                logging.warning(f"[{tid}] 기존 Media 조회 실패(무시): {e}")

        uploaded_files: List[Dict[str, Any]] = []

        # 이미지
        for p in sorted(media_dir.glob(f"{tid}_img*.jpg")):
            if not p.exists() or p.name in existing_names: continue
            temp = p.with_suffix(".upload.jpg")
            if not compress_image_to_limit(p, temp, MAX_UPLOAD_BYTES):
                logging.error(f"[{tid}] 이미지 5MiB 이하 압축 실패: {p.name}")
                if temp.exists(): temp.unlink(missing_ok=True)
                continue
            try:
                meta = notion_create_file_upload(p.name, mime_from_suffix(temp))
                notion_send_file_upload(meta["id"], temp)
                uploaded_files.append(as_uploaded_file_obj(meta["id"], p.name))
                temp.unlink(missing_ok=True); p.unlink(missing_ok=True)
                logging.info(f"[{tid}] 이미지 업로드 성공 → {p.name}")
            except Exception as e:
                logging.error(f"[{tid}] 이미지 업로드 실패({p.name}): {e}")
                if temp.exists(): temp.unlink(missing_ok=True)
            time.sleep(0.12)

        # 동영상
        v = media_dir / f"{tid}_video.mp4"
        if v.exists() and v.name not in existing_names:
            tempv = v.with_suffix(".upload.mp4")
            if compress_video_to_limit(v, tempv, MAX_UPLOAD_BYTES):
                try:
                    meta = notion_create_file_upload(v.name, mime_from_suffix(tempv))
                    notion_send_file_upload(meta["id"], tempv)
                    uploaded_files.append(as_uploaded_file_obj(meta["id"], v.name))
                    tempv.unlink(missing_ok=True); v.unlink(missing_ok=True)
                    logging.info(f"[{tid}] 동영상 업로드 성공 → {v.name}")
                except Exception as e:
                    logging.error(f"[{tid}] 동영상 업로드 실패({v.name}): {e}")
                    if tempv.exists(): tempv.unlink(missing_ok=True)
            else:
                logging.error(f"[{tid}] 동영상 5MiB 이하 압축 실패: {v.name}")
                if tempv.exists(): tempv.unlink(missing_ok=True)

        # 반영
        if uploaded_files:
            try:
                if opt_props["media"]:
                    notion_update_media_property(page_id, opt_props["media"], uploaded_files)
                    logging.info(f"[{tid}] Media 속성에 {len(uploaded_files)}개 설정")
                else:
                    notion_append_file_blocks(page_id, uploaded_files)
                    logging.info(f"[{tid}] 파일 블록으로 {len(uploaded_files)}개 첨부")
            except Exception as e:
                logging.error(f"[{tid}] 파일 반영 실패: {e}")
        else:
            logging.info(f"[{tid}] 신규 업로드 없음")

# ===================== 엔트리포인트 =====================
def main():
    run_pipeline(ACCOUNT, OUT_DIR, TARGET_COUNT, MAX_SCROLL, HEADLESS)

if __name__ == "__main__":
    main()

인천 오피스텔 성매매 조직 적발… 660명 검거 전말

1️⃣ 사건 개요 – 전국적 규모의 조직형 성매매

경찰 수사에 따르면, 이 조직은 2022년부터 2024년 초까지 인천 오피스텔 20여 곳을 임차해 운영했습니다. 업주·실장·여성 등이 역할을 나누어 철저히 분업된 형태였으며, 외부 간판 없이 비밀 예약제로 운영되었습니다. 고객은 텔레그램·문자·카톡을 통해 입실 정보를 받고, 대부분 현금으로 결제했습니다.

실제로 제가 경찰 기자로 활동하던 시절, 이와 유사한 형태의 오피스텔 성매매 단속 현장을 취재한 적이 있습니다. 문 앞까지 가면 일반 가정집처럼 꾸며져 있어 외부에서는 전혀 알아차릴 수 없었죠. 내부에는 CCTV, 잠금장치, 그리고 ‘실시간 고객관리표’가 있었습니다. 이번 사건 역시 동일한 구조로, 수익 관리와 인력 통제가 놀라울 정도로 정교했습니다.

2️⃣ 운영 수법 – 디지털 기술을 악용한 ‘보이지 않는 범죄’

업주들은 대포폰과 텔레그램을 이용해 경찰의 단속망을 피했습니다. 성매매 알선 사이트를 통해 광고를 올리고, 문의가 오면 익명 계정으로 응대했습니다. 영업 방식은 “완벽히 비대면”이었죠. 여기에 CCTV, 실시간 채팅방, 암호화된 대화 기록을 활용해 보안을 유지했습니다.

제가 취재 중 만난 수사관은 “단속보다 ‘디지털 추적’이 더 어렵다”고 말했습니다. 메시지가 자동 삭제되거나 해외 서버에 저장되면 증거 확보가 사실상 불가능하다고 합니다. 특히 최근 몇 년간 ‘온라인 알선 → 오피스텔 성매매 연결’ 구조가 급증하면서, 경찰은 전문 IT 수사팀을 운영 중입니다.

3️⃣ 법적 대응 – 성매매처벌법과 범죄수익 환수의 한계

현행법상 성매매는 구매자와 판매자 모두 형사처벌 대상입니다. 성매수자는 1년 이하 징역 또는 1천만 원 이하 벌금형, 알선자는 최대 7년 이하 징역형을 받을 수 있습니다. 이번 사건에서 경찰은 약 12억 원 상당의 자산을 ‘기소 전 추징보전’ 조치했습니다.

하지만 법조계에서는 “현행 처벌 수위가 억제력으로 충분하지 않다”는 지적이 나옵니다. 실제로 동일 인물이 다른 지역에서 재범을 저지르는 경우도 적지 않습니다. 저는 과거 판례를 분석하며, ‘단속보다 자금 추적’이 범죄 억제에 더 효과적이라는 점을 확인했습니다. 돈의 흐름을 끊지 않으면, 시스템은 다시 만들어집니다.

4️⃣ 사회적 파장 – 공직자 연루와 신뢰의 붕괴

성매수 남성 590명 중 17명이 공직자였다는 사실이 드러나며 사회적 파문이 일었습니다. 비록 고위직은 아니지만, 국민의 세금으로 급여를 받는 공무원이 불법 성매매에 가담했다는 점에서 비판 여론이 거셉니다. 이는 단순한 개인 일탈을 넘어, 공공윤리 붕괴의 징후로 해석됩니다.

실제로 제가 만난 한 시민은 “공직자가 법을 어기면 국민이 뭘 믿겠냐”며 분노를 표했습니다. 이번 사건은 공공기관의 내부 감찰 시스템, 그리고 성매매 교육의 필요성을 강하게 시사하고 있습니다.

5️⃣ 예방과 개선책 – 온라인 성매매 근절, 기술과 인식의 싸움

전문가들은 “성매매 단속의 본질은 기술전쟁”이라고 말합니다. AI 기반 온라인 탐지 시스템, 암호화된 메신저 추적기술, 자금세탁 분석 등 기술적 접근이 필수입니다. 동시에 성매수자에 대한 강력한 사회적 제재가 필요합니다. 단순 벌금이 아닌, 신상공개·공무원 징계·사회봉사 명령 등이 병행되어야 실효성이 높습니다.

저는 이번 사건을 통해, ‘법적 처벌만으로는 부족하다’는 점을 절실히 느꼈습니다. 사회 전체가 성매매를 ‘범죄’로 인식하고, 참여하지 않겠다는 윤리적 공감대를 형성해야 진정한 변화가 시작됩니다.

결국 이번 인천 사건은 한 조직의 몰락이 아니라, 우리 사회가 마주한 ‘불법 플랫폼 경제’의 민낯을 보여준 경고입니다.

자주 묻는 질문 (FAQ)

Q1. 성매매에 가담하면 어떤 처벌을 받나요?
성매매 알선 등 행위의 처벌에 관한 법률에 따라, 구매자와 판매자 모두 1년 이하의 징역 또는 1천만 원 이하의 벌금형을 받을 수 있습니다. 알선·운영자는 더 무거운 처벌을 받게 됩니다.

Q2. 텔레그램이나 해외 사이트를 이용하면 단속을 피할 수 있나요?
불가능합니다. 경찰은 국제공조 수사와 디지털 포렌식을 통해 추적이 가능합니다. 서버 위치가 해외라도 IP 기록과 송금 경로를 통해 충분히 적발됩니다.

Q3. 성매매 수익은 어떻게 환수하나요?
수사 단계에서 ‘기소 전 추징보전’ 제도를 통해 범죄 수익을 동결하고, 재판 결과에 따라 국고로 귀속됩니다. 이번 인천 사건에서도 약 12억 원이 환수 대상이 되었습니다.

Q4. 공직자가 성매매에 연루되면 어떤 처분을 받나요?
형사처벌과 별개로 소속 기관의 징계 절차가 진행됩니다. 파면, 정직, 감봉 등 중징계가 가능하며, 재취업이 제한될 수 있습니다.

Q5. 시민이 불법 성매매를 신고하려면 어떻게 해야 하나요?
국번 없이 112나 경찰청 사이버범죄신고센터를 통해 신고할 수 있습니다. 익명 신고도 가능하며, 신고자의 신원은 철저히 보호됩니다.

2025.06.08 – [경제상식] – 트럼프 일론 머스크, “브로맨스”에서 정면충돌로…그 속사정은?

트럼프 일론 머스크, “브로맨스”에서 정면충돌로…그 속사정은?