Initial commit: VK media tools

Скрипты для выгрузки фото и видео из диалогов ВКонтакте,
обработки (дедупликация + CLIP-классификация) и загрузки в Immich.

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitignore

@@ -0,0 +1,35 @@
+# Виртуальное окружение
+.venv/
+venv/
+env/
+
+# Python кеш
+__pycache__/
+*.py[cod]
+*$py.class
+*.pyo
+
+# Файлы прогресса (генерируются скриптами)
+progress.json
+process_progress.json
+video_progress.json
+immich_upload_progress.json
+rollback_log.json
+
+# Логи
+optimizer_failed.txt
+skipped_videos.txt
+
+# Загруженные медиафайлы
+downloads/
+downloads_video/
+output/
+
+# macOS
+.DS_Store
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo

config.py

@@ -0,0 +1,85 @@
+"""
+Конфигурация скрипта для выгрузки фото из диалогов ВКонтакте.
+
+Как получить токен:
+1. Перейди по ссылке в браузере:
+   https://oauth.vk.com/authorize?client_id=2685278&scope=messages,photos,offline&redirect_uri=https://oauth.vk.com/blank.html&display=page&response_type=token&v=5.199
+2. Авторизуйся и разреши доступ
+3. Скопируй access_token из адресной строки (значение между access_token= и &expires_in)
+4. Вставь его ниже в переменную VK_TOKEN
+"""
+
+# Токен доступа VK API (обязательно заполнить)
+VK_TOKEN: str = ""
+
+# Папка для сохранения фото (относительный или абсолютный путь)
+DOWNLOAD_DIR: str = "downloads"
+
+# Папка для результатов обработки (дубликаты, мусор, review) — рядом с downloads
+OUTPUT_DIR: str = "output"
+
+# Файл прогресса для механизма resume
+PROGRESS_FILE: str = "progress.json"
+
+# Версия VK API
+API_VERSION: str = "5.199"
+
+# Минимум свободного места на диске (в МБ), при котором скрипт остановится
+MIN_FREE_SPACE_MB: int = 500
+
+# Задержка между скачиваниями файлов (секунды) — чтобы не перегружать сеть
+DOWNLOAD_DELAY: float = 0.1
+
+# Количество попыток при сетевых ошибках
+MAX_RETRIES: int = 3
+
+# Таймаут для скачивания одного фото (секунды)
+DOWNLOAD_TIMEOUT: int = 30
+
+# Количество параллельных потоков для скачивания фото
+DOWNLOAD_WORKERS: int = 8
+
+# ---------------------------------------------------------------------------
+# Настройки обработки фото (process_photos.py)
+# ---------------------------------------------------------------------------
+
+# Файл прогресса обработки
+PROCESS_PROGRESS_FILE: str = "process_progress.json"
+
+# Файл лога перемещений (для отката)
+ROLLBACK_LOG_FILE: str = "rollback_log.json"
+
+# Размер хеша (hash_size x hash_size бит, 8 = 64 бита)
+HASH_SIZE: int = 8
+
+# Порог расстояния Хэмминга для near-дубликатов (0 = только точные, 8 = средний)
+DEDUP_THRESHOLD: int = 8
+
+# Потоки для параллельного хеширования
+HASH_WORKERS: int = 8
+
+# Размер батча для CLIP-классификации
+CLIP_BATCH_SIZE: int = 16
+
+# Минимальный порог уверенности CLIP (ниже → папка _review)
+# Для CLIP ViT-B-32 cosine similarity обычно в диапазоне 0.12-0.35
+CLIP_CONFIDENCE_MIN: float = 0.15
+
+# ---------------------------------------------------------------------------
+# Настройки скачивания видео (main_video.py)
+# ---------------------------------------------------------------------------
+
+# Папка для сохранения видео
+VIDEO_DOWNLOAD_DIR: str = "downloads_video"
+
+# Файл прогресса для видео
+VIDEO_PROGRESS_FILE: str = "video_progress.json"
+
+# Потоки скачивания (меньше чем для фото — видео тяжёлые)
+VIDEO_DOWNLOAD_WORKERS: int = 4
+
+# Таймаут скачивания одного видео (секунды, видео крупнее фото)
+VIDEO_DOWNLOAD_TIMEOUT: int = 300
+
+# Минимум свободного места для видео (МБ)
+VIDEO_MIN_FREE_SPACE_MB: int = 2000

immich_upload.py

@@ -0,0 +1,647 @@
+#!/usr/bin/env python3
+"""
+Массовая загрузка фото и видео в Immich с прогресс-баром и возобновлением.
+
+Использование:
+    1. pip install requests tqdm
+    2. python immich_upload.py
+    3. Ctrl+C для остановки (прогресс сохраняется автоматически)
+    4. Повторный запуск продолжит с места остановки
+"""
+
+import hashlib
+import json
+import os
+import re
+import signal
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from threading import Lock
+from typing import Optional
+
+import requests
+from tqdm import tqdm
+
+# ---------------------------------------------------------------------------
+# Конфигурация
+# ---------------------------------------------------------------------------
+
+# Immich сервер (через Upload Optimizer прокси)
+IMMICH_URL: str = "http://YOUR_IMMICH_HOST:2283"
+# Прямой доступ к Immich (минуя оптимизатор) — fallback при ошибках оптимизатора
+IMMICH_DIRECT_URL: str = "http://YOUR_IMMICH_HOST:2284"
+API_KEY: str = ""
+
+# Папки для загрузки (рекурсивный поиск медиафайлов)
+UPLOAD_FOLDERS: list[str] = [
+    "downloads_video",
+]
+
+# Файл прогресса (для resume)
+PROGRESS_FILE: str = "immich_upload_progress.json"
+
+# Лог файлов, которые оптимизатор не смог обработать (загружены напрямую)
+OPTIMIZER_FAILED_LOG: str = "optimizer_failed.txt"
+
+# Параллельные загрузки (8 потоков — оптимально для 1 Гбит LAN)
+MAX_WORKERS: int = 8
+
+# Повторные попытки при ошибке
+MAX_RETRIES: int = 3
+
+# Таймаут загрузки одного файла (секунды)
+UPLOAD_TIMEOUT: int = 300
+
+# Расширения изображений
+IMAGE_EXTENSIONS: set[str] = {
+    ".jpg", ".jpeg", ".png", ".heic", ".heif", ".webp", ".gif",
+    ".avif", ".bmp", ".tiff", ".tif", ".jxl", ".raw", ".rw2",
+    ".dng", ".nef", ".cr2", ".arw", ".orf", ".pef", ".raf",
+}
+
+# Расширения видео
+VIDEO_EXTENSIONS: set[str] = {
+    ".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v", ".3gp",
+    ".flv", ".wmv", ".mts", ".m2ts", ".mpg", ".mpeg",
+}
+
+# Все допустимые расширения медиафайлов
+MEDIA_EXTENSIONS: set[str] = IMAGE_EXTENSIONS | VIDEO_EXTENSIONS
+
+
+# Режим загрузки: "photos" — только фото (видео пропускаются и логируются),
+#                 "videos" — только видео, "all" — всё
+UPLOAD_MODE: str = "videos"
+
+# Лог пропущенных видео (при UPLOAD_MODE="photos")
+SKIPPED_VIDEOS_LOG: str = "skipped_videos.txt"
+
+# Идентификатор устройства (для Immich)
+DEVICE_ID: str = "python-bulk-uploader"
+
+
+# ---------------------------------------------------------------------------
+# Модели данных
+# ---------------------------------------------------------------------------
+
+@dataclass
+class UploadStats:
+    """Статистика загрузки (потокобезопасная)."""
+
+    uploaded: int = 0
+    skipped: int = 0
+    duplicates: int = 0
+    errors: int = 0
+    bytes_sent: int = 0
+    _lock: Lock = field(default_factory=Lock, repr=False)
+
+    def inc_uploaded(self, size: int) -> None:
+        with self._lock:
+            self.uploaded += 1
+            self.bytes_sent += size
+
+    def inc_skipped(self) -> None:
+        with self._lock:
+            self.skipped += 1
+
+    def inc_duplicate(self) -> None:
+        with self._lock:
+            self.duplicates += 1
+
+    def inc_error(self) -> None:
+        with self._lock:
+            self.errors += 1
+
+
+# ---------------------------------------------------------------------------
+# Менеджер прогресса (resume)
+# ---------------------------------------------------------------------------
+
+class ProgressManager:
+    """Управление файлом прогресса для механизма resume."""
+
+    def __init__(self, progress_file: str) -> None:
+        self.progress_file: Path = Path(progress_file)
+        self._lock: Lock = Lock()
+        self.data: dict = self._load()
+        # Множество для быстрого поиска уже загруженных файлов (по хешу пути)
+        self._uploaded_hashes: set[str] = set(self.data.get("uploaded_hashes", []))
+
+    def _load(self) -> dict:
+        """Загружает прогресс из файла или создаёт пустой."""
+        if self.progress_file.exists():
+            try:
+                with open(self.progress_file, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, OSError):
+                pass
+        return {
+            "version": 1,
+            "last_updated": "",
+            "uploaded_hashes": [],
+            "stats": {
+                "uploaded": 0,
+                "skipped": 0,
+                "duplicates": 0,
+                "errors": 0,
+                "bytes_sent": 0,
+            },
+        }
+
+    def save(self) -> None:
+        """Сохраняет текущее состояние прогресса в файл."""
+        with self._lock:
+            self.data["last_updated"] = datetime.now().isoformat()
+            self.data["uploaded_hashes"] = list(self._uploaded_hashes)
+            tmp_path = self.progress_file.with_suffix(".tmp")
+            with open(tmp_path, "w", encoding="utf-8") as f:
+                json.dump(self.data, f, ensure_ascii=False)
+            tmp_path.replace(self.progress_file)
+
+    @staticmethod
+    def _file_hash(filepath: Path) -> str:
+        """Генерирует хеш на основе пути и размера файла (быстро, без чтения)."""
+        stat = filepath.stat()
+        key = f"{filepath.resolve()}|{stat.st_size}|{stat.st_mtime}"
+        return hashlib.md5(key.encode()).hexdigest()
+
+    def is_uploaded(self, filepath: Path) -> bool:
+        """Проверяет, был ли файл уже загружен."""
+        return self._file_hash(filepath) in self._uploaded_hashes
+
+    def mark_uploaded(self, filepath: Path) -> None:
+        """Помечает файл как загруженный."""
+        with self._lock:
+            self._uploaded_hashes.add(self._file_hash(filepath))
+
+    @property
+    def uploaded_count(self) -> int:
+        return len(self._uploaded_hashes)
+
+
+# ---------------------------------------------------------------------------
+# Сканер файлов
+# ---------------------------------------------------------------------------
+
+def scan_media_files(folders: list[str]) -> list[Path]:
+    """Рекурсивно сканирует папки, возвращает отсортированный список медиафайлов."""
+    files: list[Path] = []
+    for folder in folders:
+        root = Path(folder)
+        if not root.exists():
+            tqdm.write(f"  Папка не найдена: {folder}")
+            continue
+        for filepath in root.rglob("*"):
+            if not filepath.is_file():
+                continue
+            if filepath.suffix.lower() in MEDIA_EXTENSIONS:
+                files.append(filepath)
+    # Сортировка по имени для предсказуемого порядка
+    files.sort(key=lambda p: p.name)
+    return files
+
+
+# ---------------------------------------------------------------------------
+# Загрузчик
+# ---------------------------------------------------------------------------
+
+class ImmichUploader:
+    """Загрузка файлов в Immich через API с многопоточностью."""
+
+    def __init__(self) -> None:
+        self._stop_requested: bool = False
+        self.progress: ProgressManager = ProgressManager(PROGRESS_FILE)
+        self.stats: UploadStats = UploadStats()
+        self._optimizer_fallbacks: int = 0  # Счётчик fallback-загрузок
+        self._optimizer_log_lock: Lock = Lock()
+
+        # HTTP-сессия с пулом соединений (keep-alive)
+        self._session: requests.Session = requests.Session()
+        self._session.headers.update({
+            "Accept": "application/json",
+            "x-api-key": API_KEY,
+        })
+        # Увеличиваем пул соединений для параллельных запросов
+        adapter = requests.adapters.HTTPAdapter(
+            pool_connections=MAX_WORKERS,
+            pool_maxsize=MAX_WORKERS * 2,
+        )
+        self._session.mount("http://", adapter)
+        self._session.mount("https://", adapter)
+
+        # Обработчики сигналов для graceful shutdown
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+    def _signal_handler(self, _signum: int, _frame: object) -> None:
+        """Graceful shutdown по Ctrl+C."""
+        if self._stop_requested:
+            # Повторный Ctrl+C — тихо выходим без traceback
+            os._exit(1)
+        self._stop_requested = True
+        tqdm.write(
+            "\nПолучен сигнал остановки. "
+            "Завершаю текущие загрузки и сохраняю прогресс..."
+        )
+
+    def _check_connection(self) -> bool:
+        """Проверяет подключение к Immich."""
+        try:
+            resp = self._session.get(
+                f"{IMMICH_URL}/api/server/version", timeout=10
+            )
+            data = resp.json()
+            version = f"v{data['major']}.{data['minor']}.{data['patch']}"
+            tqdm.write(f"Immich сервер: {version} ({IMMICH_URL})")
+            return True
+        except Exception as exc:
+            tqdm.write(f"ОШИБКА: Не удалось подключиться к Immich: {exc}")
+            return False
+
+    def _check_auth(self) -> bool:
+        """Проверяет API-ключ."""
+        try:
+            resp = self._session.get(
+                f"{IMMICH_URL}/api/users/me", timeout=10
+            )
+            if resp.status_code == 200:
+                user = resp.json()
+                tqdm.write(f"Авторизован как: {user.get('name', user.get('email', '?'))}")
+                return True
+            tqdm.write(f"ОШИБКА авторизации: HTTP {resp.status_code}")
+            return False
+        except Exception as exc:
+            tqdm.write(f"ОШИБКА авторизации: {exc}")
+            return False
+
+    # Паттерны даты в именах файлов
+    _FILENAME_DATE_PATTERNS: list[tuple[str, str]] = [
+        # "2019-12-01 15-30-00" (Яндекс Диск)
+        (r"(\d{4}-\d{2}-\d{2})\s+(\d{2}-\d{2}-\d{2})", "%Y-%m-%d %H-%M-%S"),
+        # "20191201_153000" (стандарт камер)
+        (r"(\d{8}_\d{6})", "%Y%m%d_%H%M%S"),
+        # "2019-12-01_15-30-00"
+        (r"(\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})", "%Y-%m-%d_%H-%M-%S"),
+        # "IMG_20191201_153000"
+        (r"IMG_(\d{8}_\d{6})", "%Y%m%d_%H%M%S"),
+        # Только дата "2019-12-01"
+        (r"(\d{4}-\d{2}-\d{2})", "%Y-%m-%d"),
+    ]
+
+    @staticmethod
+    def _parse_date_from_filename(stem: str) -> Optional[datetime]:
+        """Извлекает дату из имени файла (без расширения).
+
+        Поддерживает форматы Яндекс Диска, камер и прочие.
+        """
+        for pattern, fmt in ImmichUploader._FILENAME_DATE_PATTERNS:
+            match = re.search(pattern, stem)
+            if match:
+                date_str = " ".join(match.groups()) if match.lastindex and match.lastindex > 1 else match.group(1)
+                try:
+                    return datetime.strptime(date_str, fmt)
+                except ValueError:
+                    continue
+        return None
+
+    @staticmethod
+    def _read_google_sidecar(filepath: Path) -> Optional[dict]:
+        """Читает JSON-сайдкар Google Фото (supplemental-metadata.json).
+
+        Возвращает dict с метаданными или None, если сайдкар не найден.
+        """
+        # Google Фото кладёт метаданные в файл вида: photo.jpg.supplemental-metadata.json
+        sidecar = filepath.with_name(filepath.name + ".supplemental-metadata.json")
+        if not sidecar.exists():
+            return None
+        try:
+            with open(sidecar, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError):
+            return None
+
+    def _log_optimizer_failed(self, filepath: Path) -> None:
+        """Записывает файл в лог неудачных оптимизаций."""
+        with self._optimizer_log_lock:
+            self._optimizer_fallbacks += 1
+            with open(OPTIMIZER_FAILED_LOG, "a", encoding="utf-8") as f:
+                f.write(f"{filepath}\n")
+
+    def _do_upload(self, filepath: Path, data: dict, upload_url: str) -> requests.Response:
+        """Выполняет HTTP-загрузку файла на указанный URL."""
+        with open(filepath, "rb") as f:
+            files = {"assetData": (filepath.name, f, "application/octet-stream")}
+            return self._session.post(
+                f"{upload_url}/api/assets",
+                data=data,
+                files=files,
+                timeout=UPLOAD_TIMEOUT,
+            )
+
+    def _handle_response(self, resp: requests.Response, file_size: int) -> Optional[str]:
+        """Обрабатывает ответ Immich. Возвращает статус или None если нужен retry."""
+        if resp.status_code == 201:
+            result = resp.json()
+            status = result.get("status", "created")
+            if status == "duplicate" or result.get("duplicate"):
+                self.stats.inc_duplicate()
+                return "duplicate"
+            self.stats.inc_uploaded(file_size)
+            return "created"
+        elif resp.status_code == 200:
+            # Дубликат (некоторые версии Immich)
+            self.stats.inc_duplicate()
+            return "duplicate"
+        return None  # Нужен retry или fallback
+
+    def _upload_one(self, filepath: Path) -> Optional[str]:
+        """Загружает один файл в Immich. Возвращает статус или None при ошибке.
+
+        Логика: сначала через Upload Optimizer (порт 2283).
+        Если оптимизатор вернул 400 — fallback на прямую загрузку (порт 2284).
+
+        Статусы: 'created', 'duplicate', 'error'
+        """
+        stat = filepath.stat()
+        file_size = stat.st_size
+
+        # Базовые метаданные из файловой системы
+        created_at = datetime.fromtimestamp(
+            stat.st_birthtime if hasattr(stat, "st_birthtime") else stat.st_mtime
+        )
+        modified_at = datetime.fromtimestamp(stat.st_mtime)
+
+        # 1) Пробуем парсить дату из имени файла (Яндекс Диск: "2019-12-01 15-30-00.JPG")
+        parsed_date = self._parse_date_from_filename(filepath.stem)
+        if parsed_date:
+            created_at = parsed_date
+
+        # 2) Google JSON-сайдкар перезаписывает — он точнее всего
+        sidecar = self._read_google_sidecar(filepath)
+        if sidecar:
+            photo_taken = sidecar.get("photoTakenTime", {}).get("timestamp")
+            if photo_taken:
+                try:
+                    created_at = datetime.fromtimestamp(int(photo_taken))
+                except (ValueError, OSError):
+                    pass
+
+        data = {
+            "deviceAssetId": f"{filepath.name}-{stat.st_size}-{stat.st_mtime}",
+            "deviceId": DEVICE_ID,
+            "fileCreatedAt": created_at.isoformat(),
+            "fileModifiedAt": modified_at.isoformat(),
+            "isFavorite": "false",
+        }
+
+        # GPS из Google-сайдкара (если есть и не нулевые)
+        if sidecar:
+            geo = sidecar.get("geoData", {})
+            lat = geo.get("latitude", 0.0)
+            lon = geo.get("longitude", 0.0)
+            if lat != 0.0 or lon != 0.0:
+                data["latitude"] = str(lat)
+                data["longitude"] = str(lon)
+
+        # Видео грузим напрямую — оптимизатор не умеет их обрабатывать
+        is_video = filepath.suffix.lower() in VIDEO_EXTENSIONS
+        if is_video:
+            for attempt in range(MAX_RETRIES):
+                try:
+                    resp = self._do_upload(filepath, data, IMMICH_DIRECT_URL)
+                    result = self._handle_response(resp, file_size)
+                    if result is not None:
+                        return result
+                    if attempt < MAX_RETRIES - 1:
+                        time.sleep(2 ** attempt)
+                    else:
+                        tqdm.write(
+                            f"  Ошибка загрузки {filepath.name}: "
+                            f"HTTP {resp.status_code} — {resp.text[:200]}"
+                        )
+                        self.stats.inc_error()
+                        return "error"
+                except (requests.RequestException, OSError) as exc:
+                    if attempt < MAX_RETRIES - 1:
+                        time.sleep(2 ** attempt)
+                    else:
+                        tqdm.write(f"  Ошибка загрузки {filepath.name}: {exc}")
+                        self.stats.inc_error()
+                        return "error"
+            return "error"
+
+        # --- Прямая загрузка в Immich (порт 2284), минуя оптимизатор ---
+        for attempt in range(MAX_RETRIES):
+            try:
+                resp = self._do_upload(filepath, data, IMMICH_DIRECT_URL)
+                result = self._handle_response(resp, file_size)
+                if result is not None:
+                    return result
+
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(2 ** attempt)
+                else:
+                    tqdm.write(
+                        f"  Ошибка загрузки {filepath.name}: "
+                        f"HTTP {resp.status_code} — {resp.text[:200]}"
+                    )
+                    self.stats.inc_error()
+                    return "error"
+
+            except (requests.RequestException, OSError) as exc:
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(2 ** attempt)
+                else:
+                    tqdm.write(f"  Ошибка загрузки {filepath.name}: {exc}")
+                    self.stats.inc_error()
+                    return "error"
+
+        return "error"
+
+    @staticmethod
+    def _format_size(size_bytes: int) -> str:
+        """Форматирует размер в человекочитаемый вид."""
+        for unit in ("Б", "КБ", "МБ", "ГБ"):
+            if size_bytes < 1024:
+                return f"{size_bytes:.1f} {unit}"
+            size_bytes /= 1024
+        return f"{size_bytes:.1f} ТБ"
+
+    def run(self) -> None:
+        """Запускает процесс загрузки."""
+        tqdm.write("=" * 60)
+        tqdm.write("  Массовая загрузка в Immich")
+        tqdm.write("=" * 60)
+
+        # Проверяем подключение и авторизацию
+        if not self._check_connection() or not self._check_auth():
+            sys.exit(1)
+
+        # Сканируем файлы
+        tqdm.write("\nСканирование папок...")
+        all_files = scan_media_files(UPLOAD_FOLDERS)
+        total_size = sum(f.stat().st_size for f in all_files)
+        tqdm.write(
+            f"Найдено медиафайлов: {len(all_files)} "
+            f"({self._format_size(total_size)})"
+        )
+
+        # Фильтрация по режиму (photos / videos / all)
+        if UPLOAD_MODE == "photos":
+            skipped_videos = [f for f in all_files if f.suffix.lower() in VIDEO_EXTENSIONS]
+            if skipped_videos:
+                with open(SKIPPED_VIDEOS_LOG, "w", encoding="utf-8") as vlog:
+                    for v in skipped_videos:
+                        vlog.write(f"{v}\n")
+                tqdm.write(
+                    f"Режим: только фото. Пропущено видео: {len(skipped_videos)} "
+                    f"(см. {SKIPPED_VIDEOS_LOG})"
+                )
+            all_files = [f for f in all_files if f.suffix.lower() in IMAGE_EXTENSIONS]
+        elif UPLOAD_MODE == "videos":
+            all_files = [f for f in all_files if f.suffix.lower() in VIDEO_EXTENSIONS]
+            tqdm.write(f"Режим: только видео ({len(all_files)} файлов)")
+
+        # Фильтруем уже загруженные
+        pending_files = [f for f in all_files if not self.progress.is_uploaded(f)]
+        pending_size = sum(f.stat().st_size for f in pending_files)
+        already_done = len(all_files) - len(pending_files)
+
+        tqdm.write(
+            f"Уже загружено: {already_done} файлов\n"
+            f"Осталось загрузить: {len(pending_files)} файлов "
+            f"({self._format_size(pending_size)})"
+        )
+        tqdm.write(f"Потоков: {MAX_WORKERS}")
+        tqdm.write("-" * 60)
+
+        if not pending_files:
+            tqdm.write("\nВсе файлы уже загружены!")
+            return
+
+        # Прогресс-бар с размером и скоростью МБ/с
+        bar = tqdm(
+            total=len(all_files),
+            initial=already_done,
+            desc="Загрузка",
+            unit=" файл",
+            dynamic_ncols=True,
+            bar_format=(
+                "{l_bar}{bar}| {n_fmt}/{total_fmt} "
+                "[{elapsed}<{remaining}, {rate_fmt}] {postfix}"
+            ),
+        )
+
+        # Счётчик для периодического сохранения прогресса
+        save_counter = 0
+        save_lock = Lock()
+        start_time = time.time()
+
+        def _process_file(filepath: Path) -> Optional[str]:
+            """Обёртка загрузки одного файла для ThreadPoolExecutor."""
+            if self._stop_requested:
+                return None
+            return self._upload_one(filepath)
+
+        try:
+            with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+                # Отправляем все файлы в пул
+                future_to_file = {
+                    executor.submit(_process_file, f): f
+                    for f in pending_files
+                }
+
+                for future in as_completed(future_to_file):
+                    if self._stop_requested:
+                        # Отменяем оставшиеся задачи
+                        for f in future_to_file:
+                            f.cancel()
+                        break
+
+                    filepath = future_to_file[future]
+                    try:
+                        status = future.result()
+                    except Exception as exc:
+                        tqdm.write(f"  Неожиданная ошибка ({filepath.name}): {exc}")
+                        self.stats.inc_error()
+                        status = "error"
+
+                    if status and status != "error":
+                        self.progress.mark_uploaded(filepath)
+                        # Fallback-загрузки сохраняем в прогресс сразу,
+                        # чтобы не потерять при остановке скрипта
+                        if status.startswith("fallback_"):
+                            self.progress.save()
+
+                    bar.update(1)
+
+                    # Обновляем описание с текущей скоростью
+                    elapsed = time.time() - start_time
+                    if elapsed > 0:
+                        speed = self.stats.bytes_sent / elapsed if self.stats.bytes_sent > 0 else 0
+                        speed_str = f"{self._format_size(speed)}/с" if speed > 0 else "..."
+                        fallback_str = (
+                            f" FB:{self._optimizer_fallbacks}"
+                            if self._optimizer_fallbacks > 0
+                            else ""
+                        )
+                        bar.set_postfix_str(
+                            f"{speed_str} | "
+                            f"OK:{self.stats.uploaded} "
+                            f"DUP:{self.stats.duplicates} "
+                            f"ERR:{self.stats.errors}"
+                            f"{fallback_str}",
+                            refresh=False,
+                        )
+
+                    # Сохраняем прогресс каждые 20 файлов
+                    with save_lock:
+                        save_counter += 1
+                        if save_counter % 20 == 0:
+                            self.progress.save()
+
+        finally:
+            bar.close()
+            self.progress.save()
+
+            elapsed = time.time() - start_time
+            avg_speed = self.stats.bytes_sent / elapsed if elapsed > 0 else 0
+
+            print("\n" + "=" * 60)
+            print("  Итого:")
+            print(f"    Загружено:       {self.stats.uploaded}")
+            print(f"    Дубликатов:      {self.stats.duplicates}")
+            print(f"    Пропущено:       {self.stats.skipped}")
+            print(f"    Ошибок:          {self.stats.errors}")
+            if self._optimizer_fallbacks > 0:
+                print(f"    Fallback (без оптимизации): {self._optimizer_fallbacks}")
+                print(f"    (см. {OPTIMIZER_FAILED_LOG})")
+            print(f"    Передано:        {self._format_size(self.stats.bytes_sent)}")
+            print(f"    Средняя скорость: {self._format_size(avg_speed)}/с")
+            print(f"    Время:           {elapsed:.0f} сек")
+            if self._stop_requested:
+                print(
+                    "\n  Работа остановлена. "
+                    "Запусти скрипт снова для продолжения."
+                )
+            else:
+                print("\n  Все файлы загружены!")
+            print("=" * 60)
+
+
+# ---------------------------------------------------------------------------
+# Точка входа
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    """Точка входа скрипта."""
+    uploader = ImmichUploader()
+    uploader.run()
+
+
+if __name__ == "__main__":
+    main()

main.py

@@ -0,0 +1,957 @@
+#!/usr/bin/env python3
+"""
+Скрипт для выгрузки всех фотографий из личных диалогов ВКонтакте.
+
+Использование:
+    1. Заполни VK_TOKEN в config.py (инструкция в файле)
+    2. pip install -r requirements.txt
+    3. python main.py
+    4. Ctrl+C для остановки (прогресс сохраняется автоматически)
+    5. Повторный запуск продолжит с места остановки
+"""
+
+import json
+import os
+import shutil
+import signal
+import sys
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import piexif
+import piexif.helper
+import requests
+import vk_api
+from tqdm import tqdm
+
+import config
+
+# Приоритет размеров фото ВК (от лучшего к худшему)
+PHOTO_SIZE_PRIORITY: list[str] = ["w", "z", "y", "x", "r", "q", "p", "o", "m", "s"]
+
+
+# ---------------------------------------------------------------------------
+# Модели данных
+# ---------------------------------------------------------------------------
+
+@dataclass
+class PhotoInfo:
+    """Информация о фотографии для скачивания и записи EXIF."""
+
+    photo_id: int
+    owner_id: int
+    url: str
+    date: int  # Unix timestamp сообщения / фото
+    sender_id: int
+    sender_name: str
+    message_text: str
+    photo_text: str
+    lat: Optional[float] = None
+    long: Optional[float] = None
+
+
+# ---------------------------------------------------------------------------
+# Менеджер прогресса (resume)
+# ---------------------------------------------------------------------------
+
+class ProgressManager:
+    """Управление файлом прогресса для механизма resume (потокобезопасный)."""
+
+    def __init__(self, progress_file: str) -> None:
+        self.progress_file: Path = Path(progress_file)
+        self._lock = threading.Lock()
+        self.data: dict = self._load()
+        self._downloaded_ids: set[int] = set(self.data.get("downloaded_photo_ids", []))
+
+    def _load(self) -> dict:
+        """Загружает прогресс из файла или создаёт пустой."""
+        if self.progress_file.exists():
+            try:
+                with open(self.progress_file, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, OSError):
+                pass
+        return self._default_state()
+
+    @staticmethod
+    def _default_state() -> dict:
+        """Возвращает пустое состояние прогресса."""
+        return {
+            "version": 1,
+            "last_updated": "",
+            "dialogs_total": 0,
+            "dialogs_completed": [],
+            "current_dialog": None,
+            "downloaded_photo_ids": [],
+            "stats": {
+                "photos_downloaded": 0,
+                "photos_skipped": 0,
+                "errors": 0,
+            },
+        }
+
+    def save(self) -> None:
+        """Сохраняет текущее состояние прогресса в файл."""
+        with self._lock:
+            self.data["last_updated"] = datetime.now().isoformat()
+            self.data["downloaded_photo_ids"] = list(self._downloaded_ids)
+            tmp_path = self.progress_file.with_suffix(".tmp")
+            with open(tmp_path, "w", encoding="utf-8") as f:
+                json.dump(self.data, f, ensure_ascii=False, indent=2)
+            tmp_path.replace(self.progress_file)
+
+    def is_dialog_completed(self, peer_id: int) -> bool:
+        """Проверяет, завершён ли диалог."""
+        return peer_id in self.data["dialogs_completed"]
+
+    def mark_dialog_completed(self, peer_id: int) -> None:
+        """Помечает диалог как полностью обработанный."""
+        with self._lock:
+            if peer_id not in self.data["dialogs_completed"]:
+                self.data["dialogs_completed"].append(peer_id)
+            self.data["current_dialog"] = None
+        self.save()
+
+    def set_current_dialog(self, peer_id: int) -> None:
+        """Устанавливает текущий обрабатываемый диалог."""
+        with self._lock:
+            self.data["current_dialog"] = {"peer_id": peer_id}
+        self.save()
+
+    def get_current_dialog(self) -> Optional[dict]:
+        """Возвращает текущий обрабатываемый диалог или None."""
+        return self.data.get("current_dialog")
+
+    def is_photo_downloaded(self, photo_id: int) -> bool:
+        """Проверяет, было ли фото уже скачано."""
+        return photo_id in self._downloaded_ids
+
+    def mark_photo_downloaded(self, photo_id: int) -> None:
+        """Отмечает фото как скачанное (потокобезопасно)."""
+        with self._lock:
+            self._downloaded_ids.add(photo_id)
+            self.data["stats"]["photos_downloaded"] += 1
+
+    def increment_skipped(self) -> None:
+        """Увеличивает счётчик пропущенных фото (потокобезопасно)."""
+        with self._lock:
+            self.data["stats"]["photos_skipped"] += 1
+
+    def increment_errors(self) -> None:
+        """Увеличивает счётчик ошибок (потокобезопасно)."""
+        with self._lock:
+            self.data["stats"]["errors"] += 1
+
+
+# ---------------------------------------------------------------------------
+# Запись EXIF метаданных
+# ---------------------------------------------------------------------------
+
+class ExifWriter:
+    """Запись EXIF метаданных в JPEG файлы."""
+
+    @staticmethod
+    def _decimal_to_dms(decimal_degrees: float) -> tuple[tuple, bool]:
+        """Конвертирует десятичные градусы в формат DMS для EXIF GPS."""
+        is_negative = decimal_degrees < 0
+        decimal_degrees = abs(decimal_degrees)
+        degrees = int(decimal_degrees)
+        minutes_float = (decimal_degrees - degrees) * 60
+        minutes = int(minutes_float)
+        seconds = round((minutes_float - minutes) * 60 * 10000)
+        dms = (
+            (degrees, 1),
+            (minutes, 1),
+            (seconds, 10000),
+        )
+        return dms, is_negative
+
+    @staticmethod
+    def write_exif(filepath: Path, photo_info: PhotoInfo) -> None:
+        """Записывает EXIF метаданные в файл изображения."""
+        if filepath.suffix.lower() not in (".jpg", ".jpeg"):
+            ExifWriter._write_json_meta(filepath, photo_info)
+            return
+
+        try:
+            try:
+                exif_dict = piexif.load(str(filepath))
+            except Exception:
+                exif_dict = {
+                    "0th": {}, "Exif": {}, "GPS": {}, "1st": {}, "Interop": {},
+                }
+
+            # Дата отправки сообщения
+            if photo_info.date:
+                dt = datetime.fromtimestamp(photo_info.date)
+                date_bytes = dt.strftime("%Y:%m:%d %H:%M:%S").encode("ascii")
+                exif_dict["Exif"][piexif.ExifIFD.DateTimeOriginal] = date_bytes
+                exif_dict["Exif"][piexif.ExifIFD.DateTimeDigitized] = date_bytes
+                exif_dict["0th"][piexif.ImageIFD.DateTime] = date_bytes
+
+            # Автор
+            if photo_info.sender_name:
+                artist = photo_info.sender_name.encode("utf-8")
+                exif_dict["0th"][piexif.ImageIFD.Artist] = artist
+                exif_dict["0th"][piexif.ImageIFD.Copyright] = artist
+
+            # Описание фото из ВК
+            if photo_info.photo_text:
+                exif_dict["0th"][piexif.ImageIFD.ImageDescription] = (
+                    photo_info.photo_text.encode("utf-8")
+                )
+
+            # Текст сообщения → UserComment
+            if photo_info.message_text:
+                user_comment = piexif.helper.UserComment.dump(
+                    photo_info.message_text, encoding="unicode"
+                )
+                exif_dict["Exif"][piexif.ExifIFD.UserComment] = user_comment
+
+            # GPS
+            if photo_info.lat is not None and photo_info.long is not None:
+                lat_dms, lat_neg = ExifWriter._decimal_to_dms(photo_info.lat)
+                lon_dms, lon_neg = ExifWriter._decimal_to_dms(photo_info.long)
+                exif_dict["GPS"] = {
+                    piexif.GPSIFD.GPSVersionID: (2, 3, 0, 0),
+                    piexif.GPSIFD.GPSLatitude: lat_dms,
+                    piexif.GPSIFD.GPSLatitudeRef: b"S" if lat_neg else b"N",
+                    piexif.GPSIFD.GPSLongitude: lon_dms,
+                    piexif.GPSIFD.GPSLongitudeRef: b"W" if lon_neg else b"E",
+                }
+
+            exif_bytes = piexif.dump(exif_dict)
+            piexif.insert(exif_bytes, str(filepath))
+
+        except Exception as exc:
+            tqdm.write(f"    EXIF ошибка ({filepath.name}): {exc}. Сохраняю в JSON.")
+            ExifWriter._write_json_meta(filepath, photo_info)
+
+    @staticmethod
+    def _write_json_meta(filepath: Path, photo_info: PhotoInfo) -> None:
+        """Сохраняет метаданные в JSON файл рядом с изображением."""
+        meta_path = filepath.with_suffix(filepath.suffix + ".meta.json")
+        meta: dict = {
+            "photo_id": photo_info.photo_id,
+            "date": datetime.fromtimestamp(photo_info.date).isoformat() if photo_info.date else None,
+            "sender_id": photo_info.sender_id,
+            "sender": photo_info.sender_name,
+            "message_text": photo_info.message_text,
+            "photo_text": photo_info.photo_text,
+        }
+        if photo_info.lat is not None:
+            meta["gps"] = {"lat": photo_info.lat, "long": photo_info.long}
+
+        with open(meta_path, "w", encoding="utf-8") as f:
+            json.dump(meta, f, ensure_ascii=False, indent=2)
+
+
+# ---------------------------------------------------------------------------
+# Основной загрузчик
+# ---------------------------------------------------------------------------
+
+class VKPhotoDownloader:
+    """Скачивание фото из всех личных диалогов ВКонтакте."""
+
+    def __init__(self) -> None:
+        self._stop_requested: bool = False
+        self.progress: ProgressManager = ProgressManager(config.PROGRESS_FILE)
+        self.download_dir: Path = Path(config.DOWNLOAD_DIR)
+        self.download_dir.mkdir(parents=True, exist_ok=True)
+        self._user_cache: dict[int, str] = {}
+        self._http_session: requests.Session = requests.Session()
+
+        # Обработчики сигналов для graceful shutdown
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+        # Авторизация VK API
+        self._vk_session = vk_api.VkApi(token=config.VK_TOKEN, api_version=config.API_VERSION)
+        self.api = self._vk_session.get_api()
+
+    # -- сигналы --
+
+    def _signal_handler(self, _signum: int, _frame: object) -> None:
+        """Graceful shutdown по Ctrl+C / SIGTERM."""
+        if self._stop_requested:
+            tqdm.write("\nПринудительная остановка!")
+            sys.exit(1)
+        self._stop_requested = True
+        tqdm.write(
+            "\nПолучен сигнал остановки. "
+            "Завершаю текущие загрузки и сохраняю прогресс..."
+        )
+
+    # -- утилиты --
+
+    def _check_free_space(self) -> bool:
+        """Проверяет, достаточно ли свободного места на диске."""
+        usage = shutil.disk_usage(str(self.download_dir))
+        free_mb = usage.free / (1024 * 1024)
+        if free_mb < config.MIN_FREE_SPACE_MB:
+            tqdm.write(
+                f"Недостаточно места на диске! "
+                f"Свободно: {free_mb:.0f} МБ, минимум: {config.MIN_FREE_SPACE_MB} МБ"
+            )
+            return False
+        return True
+
+    @staticmethod
+    def _safe_name(name: str) -> str:
+        """Делает строку безопасной для имени папки/файла."""
+        return "".join(c if c.isalnum() or c in ("_", "-") else "_" for c in name)
+
+    # -- VK API execute (до 25 вызовов за 1 запрос) --
+
+    def _execute(self, code: str) -> dict:
+        """Выполняет VKScript через метод execute."""
+        return self._vk_session.method("execute", {"code": code})
+
+    # -- батч-загрузка имён пользователей --
+
+    def _prefetch_user_names(self, user_ids: list[int]) -> None:
+        """Загружает имена пользователей пакетами (до 1000 за запрос)."""
+        # Разделяем на пользователей и сообщества
+        need_users: list[int] = []
+        need_groups: list[int] = []
+
+        for uid in user_ids:
+            if uid in self._user_cache or uid == 0:
+                continue
+            if uid > 2_000_000_000:
+                self._user_cache[uid] = f"Беседа_{uid - 2_000_000_000}"
+            elif uid > 0:
+                need_users.append(uid)
+            else:
+                need_groups.append(abs(uid))
+
+        # Пакетная загрузка пользователей (до 1000 за запрос)
+        for i in range(0, len(need_users), 1000):
+            batch = need_users[i:i + 1000]
+            try:
+                ids_str = ",".join(str(x) for x in batch)
+                users = self.api.users.get(user_ids=ids_str)
+                for u in users:
+                    self._user_cache[u["id"]] = f"{u['first_name']} {u['last_name']}"
+            except Exception:
+                pass
+            time.sleep(0.34)
+
+        # Пакетная загрузка сообществ (до 500 за запрос)
+        for i in range(0, len(need_groups), 500):
+            batch = need_groups[i:i + 500]
+            try:
+                ids_str = ",".join(str(x) for x in batch)
+                resp = self.api.groups.getById(group_ids=ids_str)
+                groups = resp if isinstance(resp, list) else resp.get("groups", [])
+                for g in groups:
+                    gid = -g["id"]
+                    self._user_cache[gid] = g.get("name", f"group_{g['id']}")
+            except Exception:
+                pass
+            time.sleep(0.34)
+
+    def _get_user_name(self, user_id: int) -> str:
+        """Получает имя из кэша. Если нет — дозагружает."""
+        if user_id in self._user_cache:
+            return self._user_cache[user_id]
+        # Фоллбэк на единичный запрос
+        self._prefetch_user_names([user_id])
+        return self._user_cache.get(user_id, f"id{user_id}")
+
+    # -- получение списка диалогов через execute --
+
+    def _get_all_conversations(self) -> list[dict]:
+        """Получает полный список диалогов (через execute — 25 страниц за запрос)."""
+        conversations: list[dict] = []
+        offset = 0
+
+        tqdm.write("Получаю список диалогов...")
+
+        while True:
+            # VKScript: за один execute получаем до 25 страниц по 200 диалогов
+            code = f"""
+            var results = [];
+            var offset = {offset};
+            var i = 0;
+            while (i < 25) {{
+                var resp = API.messages.getConversations({{
+                    "offset": offset, "count": 200, "extended": 0
+                }});
+                results.push(resp);
+                offset = offset + 200;
+                if (offset >= resp.count || resp.items.length == 0) {{
+                    return {{"results": results, "done": true}};
+                }}
+                i = i + 1;
+            }}
+            return {{"results": results, "done": false, "next_offset": offset}};
+            """
+            try:
+                data = self._execute(code)
+            except Exception as exc:
+                tqdm.write(f"  execute ошибка (conversations): {exc}, пробую обычный метод")
+                return self._get_all_conversations_fallback()
+
+            for page in data.get("results", []):
+                if not page:
+                    continue
+                for item in page.get("items", []):
+                    peer = item["conversation"]["peer"]
+                    if peer["type"] == "chat":
+                        continue
+                    conversations.append(
+                        {"peer_id": peer["id"], "type": peer["type"]}
+                    )
+
+            if data.get("done", True):
+                break
+            offset = data.get("next_offset", offset + 5000)
+            time.sleep(0.34)
+
+        tqdm.write(f"Найдено личных диалогов: {len(conversations)} (беседы пропущены)")
+        return conversations
+
+    def _get_all_conversations_fallback(self) -> list[dict]:
+        """Фоллбэк: получение диалогов обычным методом (без execute)."""
+        conversations: list[dict] = []
+        offset = 0
+
+        while True:
+            resp = self.api.messages.getConversations(
+                offset=offset, count=200, extended=0,
+            )
+            items = resp.get("items", [])
+            if not items:
+                break
+            for item in items:
+                peer = item["conversation"]["peer"]
+                if peer["type"] == "chat":
+                    continue
+                conversations.append(
+                    {"peer_id": peer["id"], "type": peer["type"]}
+                )
+            offset += 200
+            if offset >= resp.get("count", 0):
+                break
+            time.sleep(0.34)
+
+        return conversations
+
+    # -- выбор лучшего размера фото --
+
+    @staticmethod
+    def _best_photo_url(photo: dict) -> Optional[str]:
+        """Выбирает URL фото максимального доступного размера."""
+        orig = photo.get("orig_photo")
+        if orig and orig.get("url"):
+            return orig["url"]
+
+        sizes = photo.get("sizes")
+        if sizes:
+            size_map = {s["type"]: s["url"] for s in sizes}
+            for prio in PHOTO_SIZE_PRIORITY:
+                if prio in size_map:
+                    return size_map[prio]
+            best = max(sizes, key=lambda s: s.get("width", 0) * s.get("height", 0))
+            return best.get("url")
+
+        for key in ("photo_2560", "photo_1280", "photo_807", "photo_604", "photo_130", "photo_75"):
+            if key in photo:
+                return photo[key]
+
+        return None
+
+    # -- извлечение фото из сообщений --
+
+    def _extract_photos_recursive(self, message: dict) -> list[dict]:
+        """Рекурсивно извлекает все фото из сообщения (вложения + пересланные)."""
+        result: list[dict] = []
+
+        for att in message.get("attachments", []):
+            if att.get("type") == "photo":
+                photo = att["photo"]
+                url = self._best_photo_url(photo)
+                if url:
+                    result.append({
+                        "photo": photo,
+                        "url": url,
+                        "from_id": message.get("from_id", 0),
+                        "date": message.get("date", photo.get("date", 0)),
+                        "message_text": message.get("text", ""),
+                    })
+
+        for fwd in message.get("fwd_messages", []):
+            result.extend(self._extract_photos_recursive(fwd))
+
+        reply = message.get("reply_message")
+        if reply:
+            result.extend(self._extract_photos_recursive(reply))
+
+        return result
+
+    # -- сбор фото через execute (getHistoryAttachments, до 25 страниц за запрос) --
+
+    def _collect_all_attachment_photos(self, peer_id: int) -> list[dict]:
+        """Собирает все фото-вложения через execute (25 страниц за 1 API вызов)."""
+        all_photos: list[dict] = []
+        cursor = ""
+
+        while not self._stop_requested:
+            # VKScript: до 25 вызовов getHistoryAttachments за один execute
+            start_from_clause = (
+                f'"start_from": "{cursor}",' if cursor else ""
+            )
+            code = f"""
+            var results = [];
+            var cursor = "{cursor}";
+            var i = 0;
+            while (i < 25) {{
+                var params = {{
+                    "peer_id": {peer_id},
+                    "media_type": "photo",
+                    "count": 200,
+                    "preserve_order": 1
+                }};
+                if (cursor != "") {{
+                    params.start_from = cursor;
+                }}
+                var resp = API.messages.getHistoryAttachments(params);
+                results.push(resp);
+                if (!resp.next_from || resp.items.length == 0) {{
+                    return {{"results": results, "cursor": ""}};
+                }}
+                cursor = resp.next_from;
+                i = i + 1;
+            }}
+            return {{"results": results, "cursor": cursor}};
+            """
+            try:
+                data = self._execute(code)
+            except Exception as exc:
+                tqdm.write(f"    execute ошибка (attachments): {exc}, фоллбэк")
+                return self._collect_attachments_fallback(peer_id, all_photos, cursor)
+
+            for page in data.get("results", []):
+                if not page:
+                    continue
+                for item in page.get("items", []):
+                    att = item.get("attachment", {})
+                    if att.get("type") != "photo":
+                        continue
+                    photo = att["photo"]
+                    url = self._best_photo_url(photo)
+                    if url:
+                        all_photos.append({
+                            "photo": photo,
+                            "url": url,
+                            "from_id": item.get("from_id", 0),
+                            "date": item.get("date", photo.get("date", 0)),
+                            "message_text": "",
+                        })
+
+            cursor = data.get("cursor", "")
+            if not cursor:
+                break
+            time.sleep(0.34)
+
+        return all_photos
+
+    def _collect_attachments_fallback(
+        self, peer_id: int, existing: list[dict], start_from: str
+    ) -> list[dict]:
+        """Фоллбэк: обычная пагинация getHistoryAttachments."""
+        cursor: Optional[str] = start_from or None
+        while not self._stop_requested:
+            params: dict = {
+                "peer_id": peer_id, "media_type": "photo",
+                "count": 200, "preserve_order": 1,
+            }
+            if cursor:
+                params["start_from"] = cursor
+            resp = self.api.messages.getHistoryAttachments(**params)
+            items = resp.get("items", [])
+            cursor = resp.get("next_from")
+            if not items:
+                break
+            for item in items:
+                att = item.get("attachment", {})
+                if att.get("type") != "photo":
+                    continue
+                photo = att["photo"]
+                url = self._best_photo_url(photo)
+                if url:
+                    existing.append({
+                        "photo": photo, "url": url,
+                        "from_id": item.get("from_id", 0),
+                        "date": item.get("date", photo.get("date", 0)),
+                        "message_text": "",
+                    })
+            if not cursor:
+                break
+            time.sleep(0.34)
+        return existing
+
+    # -- сбор фото из пересланных через execute (getHistory) --
+
+    def _collect_forwarded_photos(
+        self, peer_id: int, known_ids: set[int],
+    ) -> list[dict]:
+        """Сканирует историю сообщений через execute (25 страниц за запрос)."""
+        found: list[dict] = []
+        offset = 0
+
+        while not self._stop_requested:
+            code = f"""
+            var results = [];
+            var offset = {offset};
+            var i = 0;
+            while (i < 25) {{
+                var resp = API.messages.getHistory({{
+                    "peer_id": {peer_id}, "offset": offset, "count": 200
+                }});
+                results.push(resp);
+                offset = offset + 200;
+                if (offset >= resp.count || resp.items.length == 0) {{
+                    return {{"results": results, "done": true}};
+                }}
+                i = i + 1;
+            }}
+            return {{"results": results, "done": false, "next_offset": offset}};
+            """
+            try:
+                data = self._execute(code)
+            except vk_api.exceptions.ApiError as exc:
+                tqdm.write(f"    API ошибка при getHistory: {exc}")
+                break
+            except Exception as exc:
+                tqdm.write(f"    execute ошибка (history): {exc}, прерываю сканирование")
+                break
+
+            for page in data.get("results", []):
+                if not page:
+                    continue
+                for msg in page.get("items", []):
+                    sources: list[dict] = []
+                    for fwd in msg.get("fwd_messages", []):
+                        sources.extend(self._extract_photos_recursive(fwd))
+                    reply = msg.get("reply_message")
+                    if reply:
+                        sources.extend(self._extract_photos_recursive(reply))
+
+                    for item in sources:
+                        pid = item["photo"].get("id", 0)
+                        if pid and pid not in known_ids:
+                            known_ids.add(pid)
+                            if not item.get("message_text"):
+                                item["message_text"] = msg.get("text", "")
+                            found.append(item)
+
+            if data.get("done", True):
+                break
+            offset = data.get("next_offset", offset + 5000)
+            time.sleep(0.34)
+
+        return found
+
+    # -- скачивание одного фото (для потока) --
+
+    def _download_single(
+        self, photo_data: dict, dialog_dir: Path
+    ) -> Optional[PhotoInfo]:
+        """Скачивает одно фото, записывает EXIF и utime. Возвращает PhotoInfo или None."""
+        photo = photo_data["photo"]
+        photo_id = photo.get("id", 0)
+        url = photo_data["url"]
+        date_ts: int = photo_data.get("date", photo.get("date", 0))
+
+        # Формируем путь: dialog_dir / YYYY / photo_{id}_{date}.jpg
+        dt = datetime.fromtimestamp(date_ts) if date_ts else datetime.now()
+        subfolder = dt.strftime("%Y")
+        filename = f"photo_{photo_id}_{dt.strftime('%Y%m%d_%H%M%S')}.jpg"
+        filepath = dialog_dir / subfolder / filename
+
+        # Скачиваем с retry
+        for attempt in range(config.MAX_RETRIES):
+            try:
+                resp = self._http_session.get(
+                    url, timeout=config.DOWNLOAD_TIMEOUT, stream=True
+                )
+                resp.raise_for_status()
+                filepath.parent.mkdir(parents=True, exist_ok=True)
+                with open(filepath, "wb") as f:
+                    for chunk in resp.iter_content(chunk_size=8192):
+                        f.write(chunk)
+                break
+            except (requests.RequestException, OSError) as exc:
+                if attempt < config.MAX_RETRIES - 1:
+                    time.sleep(2 ** attempt)
+                else:
+                    tqdm.write(f"    Ошибка скачивания ({filename}): {exc}")
+                    return None
+
+        # Метаданные
+        sender_id = photo_data.get("from_id", 0)
+        sender_name = self._user_cache.get(sender_id, f"id{sender_id}") if sender_id else ""
+
+        info = PhotoInfo(
+            photo_id=photo_id,
+            owner_id=photo.get("owner_id", 0),
+            url=url,
+            date=date_ts,
+            sender_id=sender_id,
+            sender_name=sender_name,
+            message_text=photo_data.get("message_text", ""),
+            photo_text=photo.get("text", ""),
+            lat=photo.get("lat"),
+            long=photo.get("long"),
+        )
+
+        # EXIF
+        ExifWriter.write_exif(filepath, info)
+
+        # Дата файла = дата сообщения
+        if date_ts:
+            os.utime(filepath, (date_ts, date_ts))
+
+        return info
+
+    # -- обработка одного диалога --
+
+    def _process_dialog(
+        self, peer_id: int, dialog_name: str, photos_bar: tqdm
+    ) -> None:
+        """Обрабатывает один диалог: собирает и скачивает все фото."""
+
+        saved = self.progress.get_current_dialog()
+        resuming = saved is not None and saved.get("peer_id") == peer_id
+
+        if not resuming:
+            self.progress.set_current_dialog(peer_id)
+
+        known_ids: set[int] = set()
+        all_photos: list[dict] = []
+
+        # Фаза 1: вложения через execute + getHistoryAttachments
+        tqdm.write(f"  [{dialog_name}] Сбор фото-вложений...")
+        att_photos = self._collect_all_attachment_photos(peer_id)
+        for p in att_photos:
+            pid = p["photo"].get("id", 0)
+            if pid and pid not in known_ids:
+                known_ids.add(pid)
+                all_photos.append(p)
+
+        # Фаза 2: пересланные сообщения через execute + getHistory
+        if not self._stop_requested:
+            tqdm.write(f"  [{dialog_name}] Поиск фото в пересланных сообщениях...")
+            fwd_photos = self._collect_forwarded_photos(peer_id, known_ids)
+            all_photos.extend(fwd_photos)
+
+        if not all_photos:
+            tqdm.write(f"  [{dialog_name}] Нет фото")
+            if not self._stop_requested:
+                self.progress.mark_dialog_completed(peer_id)
+            return
+
+        # Фильтруем уже скачанные
+        tasks = [
+            p for p in all_photos
+            if not self.progress.is_photo_downloaded(p["photo"].get("id", 0))
+        ]
+        skipped = len(all_photos) - len(tasks)
+
+        tqdm.write(
+            f"  [{dialog_name}] Всего: {len(all_photos)}, "
+            f"скачать: {len(tasks)}, пропустить: {skipped}"
+        )
+
+        if not tasks:
+            if not self._stop_requested:
+                self.progress.mark_dialog_completed(peer_id)
+            return
+
+        # Предзагрузка имён отправителей пакетом
+        sender_ids = list({t.get("from_id", 0) for t in tasks if t.get("from_id", 0)})
+        if sender_ids:
+            self._prefetch_user_names(sender_ids)
+
+        # Настройка прогресс-бара
+        photos_bar.reset(total=len(all_photos))
+        photos_bar.n = skipped
+        photos_bar.refresh()
+        photos_bar.set_description(f"Фото ({dialog_name[:25]})")
+
+        safe_dialog = self._safe_name(dialog_name)
+        dialog_dir = self.download_dir / f"{safe_dialog}_id{peer_id}"
+
+        # -- Параллельное скачивание через ThreadPoolExecutor --
+        completed_count = 0
+
+        with ThreadPoolExecutor(max_workers=config.DOWNLOAD_WORKERS) as executor:
+            futures: dict = {}
+
+            for task in tasks:
+                if self._stop_requested:
+                    break
+                if not self._check_free_space():
+                    tqdm.write("Остановка из-за нехватки места на диске.")
+                    self._stop_requested = True
+                    break
+                future = executor.submit(self._download_single, task, dialog_dir)
+                futures[future] = task
+
+            for future in as_completed(futures):
+                task = futures[future]
+                photo_id = task["photo"].get("id", 0)
+
+                try:
+                    result = future.result()
+                    if result is not None:
+                        self.progress.mark_photo_downloaded(photo_id)
+                    else:
+                        self.progress.increment_errors()
+                except Exception:
+                    self.progress.increment_errors()
+
+                photos_bar.update(1)
+                completed_count += 1
+
+                # Сохраняем прогресс каждые 50 фото
+                if completed_count % 50 == 0:
+                    self.progress.save()
+
+                if self._stop_requested:
+                    # Отменяем ещё не запущенные задачи
+                    for f in futures:
+                        f.cancel()
+                    break
+
+        self.progress.save()
+
+        if not self._stop_requested:
+            self.progress.mark_dialog_completed(peer_id)
+
+    # -- главный цикл --
+
+    def run(self) -> None:
+        """Запускает процесс скачивания фотографий."""
+        tqdm.write("=" * 60)
+        tqdm.write("  Выгрузка фото из диалогов ВКонтакте")
+        tqdm.write(f"  Потоков скачивания: {config.DOWNLOAD_WORKERS}")
+        tqdm.write("=" * 60)
+
+        if not config.VK_TOKEN:
+            tqdm.write(
+                "ОШИБКА: Заполни VK_TOKEN в config.py!\n"
+                "Инструкция по получению токена — в комментарии в config.py"
+            )
+            sys.exit(1)
+
+        try:
+            me = self.api.users.get()[0]
+            my_name = f"{me['first_name']} {me['last_name']}"
+            tqdm.write(f"Авторизован как: {my_name}")
+            self._user_cache[me["id"]] = my_name
+        except Exception as exc:
+            tqdm.write(f"ОШИБКА авторизации: {exc}")
+            tqdm.write("Проверь VK_TOKEN в config.py")
+            sys.exit(1)
+
+        conversations = self._get_all_conversations()
+        self.progress.data["dialogs_total"] = len(conversations)
+        self.progress.save()
+
+        # Предзагрузка имён для всех собеседников
+        peer_ids = [c["peer_id"] for c in conversations]
+        tqdm.write("Загружаю имена собеседников...")
+        self._prefetch_user_names(peer_ids)
+
+        completed_ids: set[int] = set(self.progress.data["dialogs_completed"])
+        remaining = [c for c in conversations if c["peer_id"] not in completed_ids]
+
+        current = self.progress.get_current_dialog()
+        if current:
+            cur_pid = current["peer_id"]
+            remaining = [c for c in remaining if c["peer_id"] != cur_pid]
+            for c in conversations:
+                if c["peer_id"] == cur_pid:
+                    remaining.insert(0, c)
+                    break
+
+        stats = self.progress.data["stats"]
+        tqdm.write(
+            f"\nПрогресс: {len(completed_ids)}/{len(conversations)} диалогов, "
+            f"{stats['photos_downloaded']} фото уже скачано"
+        )
+        tqdm.write(f"Осталось обработать: {len(remaining)} диалогов")
+        tqdm.write("-" * 60)
+
+        dialogs_bar = tqdm(
+            total=len(conversations),
+            initial=len(completed_ids),
+            desc="Диалоги",
+            unit=" диал",
+            position=0,
+            dynamic_ncols=True,
+        )
+        photos_bar = tqdm(
+            total=0,
+            desc="Фото",
+            unit=" фото",
+            position=1,
+            leave=False,
+            dynamic_ncols=True,
+        )
+
+        try:
+            for conv in remaining:
+                if self._stop_requested:
+                    break
+
+                peer_id = conv["peer_id"]
+                dialog_name = self._get_user_name(peer_id)
+
+                self._process_dialog(peer_id, dialog_name, photos_bar)
+
+                if not self._stop_requested:
+                    dialogs_bar.update(1)
+
+        finally:
+            photos_bar.close()
+            dialogs_bar.close()
+            self.progress.save()
+
+            stats = self.progress.data["stats"]
+            completed_count = len(self.progress.data["dialogs_completed"])
+            total_count = self.progress.data["dialogs_total"]
+
+            print("\n" + "=" * 60)
+            print("  Итого:")
+            print(f"    Фото скачано:         {stats['photos_downloaded']}")
+            print(f"    Фото пропущено:       {stats['photos_skipped']}")
+            print(f"    Ошибок:               {stats['errors']}")
+            print(f"    Диалогов обработано:  {completed_count}/{total_count}")
+            if self._stop_requested:
+                print("\n  Работа остановлена. Запусти скрипт снова для продолжения.")
+            else:
+                print("\n  Все диалоги обработаны!")
+            print("=" * 60)
+
+
+# ---------------------------------------------------------------------------
+# Точка входа
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    """Точка входа скрипта."""
+    downloader = VKPhotoDownloader()
+    downloader.run()
+
+
+if __name__ == "__main__":
+    main()

main_video.py

@@ -0,0 +1,823 @@
+#!/usr/bin/env python3
+"""
+Скрипт для выгрузки СВОИХ видео из личных диалогов ВКонтакте.
+
+Скачивает только видео, где owner_id == ваш ID (загруженные вами).
+Чужие видео, видео сообществ — пропускаются.
+
+Использование:
+    1. Заполни VK_TOKEN в config.py
+    2. pip install -r requirements.txt
+    3. python main_video.py
+    4. Ctrl+C для остановки (прогресс сохраняется)
+    5. Повторный запуск продолжит с места остановки
+"""
+
+import json
+import os
+import shutil
+import signal
+import sys
+import threading
+import time
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import requests
+import vk_api
+from tqdm import tqdm
+
+import config
+
+# Приоритет качества видео (от лучшего к худшему)
+VIDEO_QUALITY_PRIORITY: list[str] = [
+    "mp4_2160", "mp4_1440", "mp4_1080", "mp4_720", "mp4_480", "mp4_360", "mp4_240", "mp4_144",
+]
+
+
+# ---------------------------------------------------------------------------
+# Модели данных
+# ---------------------------------------------------------------------------
+
+@dataclass
+class VideoMeta:
+    """Метаданные видео для JSON-сайдкара."""
+
+    video_id: int
+    owner_id: int
+    title: str
+    duration: int
+    date: int
+    sender_id: int
+    sender_name: str
+    message_text: str
+    quality: str
+
+
+# ---------------------------------------------------------------------------
+# Менеджер прогресса
+# ---------------------------------------------------------------------------
+
+class ProgressManager:
+    """Прогресс с resume-механизмом (потокобезопасный)."""
+
+    def __init__(self, progress_file: str) -> None:
+        self.progress_file: Path = Path(progress_file)
+        self._lock = threading.Lock()
+        self.data: dict = self._load()
+        self._downloaded_ids: set[int] = set(
+            self.data.get("downloaded_video_ids", [])
+        )
+
+    def _load(self) -> dict:
+        if self.progress_file.exists():
+            try:
+                with open(self.progress_file, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, OSError):
+                pass
+        return self._default_state()
+
+    @staticmethod
+    def _default_state() -> dict:
+        return {
+            "version": 3,
+            "last_updated": "",
+            "dialogs_total": 0,
+            "dialogs_completed": [],
+            "current_dialog": None,
+            "downloaded_video_ids": [],
+            "stats": {
+                "videos_downloaded": 0,
+                "foreign_skipped": 0,
+                "external_saved": 0,
+                "no_files": 0,
+                "errors": 0,
+                "bytes_downloaded": 0,
+            },
+        }
+
+    def save(self) -> None:
+        with self._lock:
+            self.data["last_updated"] = datetime.now().isoformat()
+            self.data["downloaded_video_ids"] = list(self._downloaded_ids)
+            tmp = self.progress_file.with_suffix(".tmp")
+            with open(tmp, "w", encoding="utf-8") as f:
+                json.dump(self.data, f, ensure_ascii=False, indent=2)
+            tmp.replace(self.progress_file)
+
+    def is_dialog_completed(self, peer_id: int) -> bool:
+        return peer_id in self.data["dialogs_completed"]
+
+    def mark_dialog_completed(self, peer_id: int) -> None:
+        with self._lock:
+            if peer_id not in self.data["dialogs_completed"]:
+                self.data["dialogs_completed"].append(peer_id)
+            self.data["current_dialog"] = None
+        self.save()
+
+    def set_current_dialog(self, peer_id: int) -> None:
+        with self._lock:
+            self.data["current_dialog"] = {"peer_id": peer_id}
+        self.save()
+
+    def get_current_dialog(self) -> Optional[dict]:
+        return self.data.get("current_dialog")
+
+    def is_video_downloaded(self, video_id: int) -> bool:
+        return video_id in self._downloaded_ids
+
+    def mark_video_downloaded(self, video_id: int, size: int) -> None:
+        with self._lock:
+            self._downloaded_ids.add(video_id)
+            self.data["stats"]["videos_downloaded"] += 1
+            self.data["stats"]["bytes_downloaded"] += size
+
+    def increment_foreign(self, count: int = 1) -> None:
+        with self._lock:
+            self.data["stats"]["foreign_skipped"] += count
+
+    def increment_external(self) -> None:
+        with self._lock:
+            self.data["stats"]["external_saved"] += 1
+
+    def increment_no_files(self) -> None:
+        with self._lock:
+            self.data["stats"]["no_files"] += 1
+
+    def increment_errors(self) -> None:
+        with self._lock:
+            self.data["stats"]["errors"] += 1
+
+
+# ---------------------------------------------------------------------------
+# Основной загрузчик
+# ---------------------------------------------------------------------------
+
+class VKVideoDownloader:
+    """Скачивание своих видео из диалогов ВК."""
+
+    def __init__(self) -> None:
+        self._stop_requested: bool = False
+        self.progress = ProgressManager(config.VIDEO_PROGRESS_FILE)
+        self.download_dir = Path(config.VIDEO_DOWNLOAD_DIR)
+        self.download_dir.mkdir(parents=True, exist_ok=True)
+        self._user_cache: dict[int, str] = {}
+        self._my_id: int = 0
+
+        # HTTP-сессия для скачивания файлов
+        self._http = requests.Session()
+
+        # Отдельная сессия для video.get БЕЗ User-Agent браузера
+        # (VK не отдаёт поле files если видит браузерный UA)
+        self._video_api_session = requests.Session()
+
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+        # vk_api для всего кроме video.get
+        self._vk_session = vk_api.VkApi(
+            token=config.VK_TOKEN, api_version=config.API_VERSION,
+        )
+        self.api = self._vk_session.get_api()
+
+    def _signal_handler(self, _signum: int, _frame: object) -> None:
+        if self._stop_requested:
+            tqdm.write("\nПринудительная остановка!")
+            sys.exit(1)
+        self._stop_requested = True
+        tqdm.write("\nОстановка... сохраняю прогресс.")
+
+    # -- утилиты --
+
+    def _check_free_space(self) -> bool:
+        usage = shutil.disk_usage(str(self.download_dir))
+        free_mb = usage.free / (1024 * 1024)
+        if free_mb < config.VIDEO_MIN_FREE_SPACE_MB:
+            tqdm.write(
+                f"Мало места! Свободно: {free_mb:.0f} МБ, "
+                f"минимум: {config.VIDEO_MIN_FREE_SPACE_MB} МБ"
+            )
+            return False
+        return True
+
+    @staticmethod
+    def _safe_name(name: str) -> str:
+        return "".join(c if c.isalnum() or c in ("_", "-") else "_" for c in name)
+
+    @staticmethod
+    def _format_size(size_bytes: int) -> str:
+        sz = float(size_bytes)
+        for unit in ("Б", "КБ", "МБ", "ГБ"):
+            if sz < 1024:
+                return f"{sz:.1f} {unit}"
+            sz /= 1024
+        return f"{sz:.1f} ТБ"
+
+    @staticmethod
+    def _format_duration(seconds: int) -> str:
+        m, s = divmod(seconds, 60)
+        h, m = divmod(m, 60)
+        if h:
+            return f"{h}:{m:02d}:{s:02d}"
+        return f"{m}:{s:02d}"
+
+    # -- VK API --
+
+    def _execute(self, code: str) -> dict:
+        return self._vk_session.method("execute", {"code": code})
+
+    def _video_get_raw(self, video_keys: list[str]) -> list[dict]:
+        """Вызов video.get через requests БЕЗ браузерного User-Agent.
+
+        VK не отдаёт поле files если видит User-Agent браузера.
+        """
+        result: list[dict] = []
+        for i in range(0, len(video_keys), 200):
+            if self._stop_requested:
+                break
+            batch = video_keys[i:i + 200]
+            try:
+                resp = self._video_api_session.post(
+                    "https://api.vk.com/method/video.get",
+                    data={
+                        "videos": ",".join(batch),
+                        "access_token": config.VK_TOKEN,
+                        "v": config.API_VERSION,
+                    },
+                    timeout=30,
+                )
+                data = resp.json()
+                items = data.get("response", {}).get("items", [])
+                result.extend(items)
+            except Exception as exc:
+                tqdm.write(f"    video.get ошибка: {exc}")
+            time.sleep(0.34)
+        return result
+
+    def _prefetch_user_names(self, user_ids: list[int]) -> None:
+        need_users: list[int] = []
+        need_groups: list[int] = []
+
+        for uid in user_ids:
+            if uid in self._user_cache or uid == 0:
+                continue
+            if uid > 2_000_000_000:
+                self._user_cache[uid] = f"Беседа_{uid - 2_000_000_000}"
+            elif uid > 0:
+                need_users.append(uid)
+            else:
+                need_groups.append(abs(uid))
+
+        for i in range(0, len(need_users), 1000):
+            batch = need_users[i:i + 1000]
+            try:
+                ids_str = ",".join(str(x) for x in batch)
+                users = self.api.users.get(user_ids=ids_str)
+                for u in users:
+                    self._user_cache[u["id"]] = f"{u['first_name']} {u['last_name']}"
+            except Exception:
+                pass
+            time.sleep(0.34)
+
+        for i in range(0, len(need_groups), 500):
+            batch = need_groups[i:i + 500]
+            try:
+                ids_str = ",".join(str(x) for x in batch)
+                resp = self.api.groups.getById(group_ids=ids_str)
+                groups = resp if isinstance(resp, list) else resp.get("groups", [])
+                for g in groups:
+                    self._user_cache[-g["id"]] = g.get("name", f"group_{g['id']}")
+            except Exception:
+                pass
+            time.sleep(0.34)
+
+    def _get_user_name(self, user_id: int) -> str:
+        if user_id in self._user_cache:
+            return self._user_cache[user_id]
+        self._prefetch_user_names([user_id])
+        return self._user_cache.get(user_id, f"id{user_id}")
+
+    # -- получение диалогов --
+
+    def _get_all_conversations(self) -> list[dict]:
+        conversations: list[dict] = []
+        offset = 0
+
+        tqdm.write("Получаю список диалогов...")
+        while True:
+            code = f"""
+            var results = [];
+            var offset = {offset};
+            var i = 0;
+            while (i < 25) {{
+                var resp = API.messages.getConversations({{
+                    "offset": offset, "count": 200, "extended": 0
+                }});
+                results.push(resp);
+                offset = offset + 200;
+                if (offset >= resp.count || resp.items.length == 0) {{
+                    return {{"results": results, "done": true}};
+                }}
+                i = i + 1;
+            }}
+            return {{"results": results, "done": false, "next_offset": offset}};
+            """
+            try:
+                data = self._execute(code)
+            except Exception as exc:
+                tqdm.write(f"  execute ошибка: {exc}, фоллбэк")
+                return self._get_conversations_fallback()
+
+            for page in data.get("results", []):
+                if not page:
+                    continue
+                for item in page.get("items", []):
+                    peer = item["conversation"]["peer"]
+                    if peer["type"] == "chat":
+                        continue
+                    conversations.append(
+                        {"peer_id": peer["id"], "type": peer["type"]}
+                    )
+
+            if data.get("done", True):
+                break
+            offset = data.get("next_offset", offset + 5000)
+            time.sleep(0.34)
+
+        tqdm.write(f"Найдено личных диалогов: {len(conversations)}")
+        return conversations
+
+    def _get_conversations_fallback(self) -> list[dict]:
+        conversations: list[dict] = []
+        offset = 0
+        while True:
+            resp = self.api.messages.getConversations(
+                offset=offset, count=200, extended=0,
+            )
+            items = resp.get("items", [])
+            if not items:
+                break
+            for item in items:
+                peer = item["conversation"]["peer"]
+                if peer["type"] == "chat":
+                    continue
+                conversations.append(
+                    {"peer_id": peer["id"], "type": peer["type"]}
+                )
+            offset += 200
+            if offset >= resp.get("count", 0):
+                break
+            time.sleep(0.34)
+        return conversations
+
+    # -- сбор видео-вложений --
+
+    def _collect_my_videos(self, peer_id: int) -> list[dict]:
+        """Собирает видео-вложения, фильтруя только свои (owner_id == my_id)."""
+        all_videos: list[dict] = []
+        cursor = ""
+        foreign_count = 0
+
+        while not self._stop_requested:
+            code = f"""
+            var results = [];
+            var cursor = "{cursor}";
+            var i = 0;
+            while (i < 25) {{
+                var params = {{
+                    "peer_id": {peer_id},
+                    "media_type": "video",
+                    "count": 200,
+                    "preserve_order": 1
+                }};
+                if (cursor != "") {{
+                    params.start_from = cursor;
+                }}
+                var resp = API.messages.getHistoryAttachments(params);
+                results.push(resp);
+                if (!resp.next_from || resp.items.length == 0) {{
+                    return {{"results": results, "cursor": ""}};
+                }}
+                cursor = resp.next_from;
+                i = i + 1;
+            }}
+            return {{"results": results, "cursor": cursor}};
+            """
+            try:
+                data = self._execute(code)
+            except Exception as exc:
+                tqdm.write(f"    execute ошибка: {exc}, фоллбэк")
+                fb_result, fb_foreign = self._collect_videos_fallback(
+                    peer_id, all_videos, cursor,
+                )
+                foreign_count += fb_foreign
+                break
+
+            for page in data.get("results", []):
+                if not page:
+                    continue
+                for item in page.get("items", []):
+                    att = item.get("attachment", {})
+                    if att.get("type") != "video":
+                        continue
+                    video = att["video"]
+                    if video.get("owner_id") != self._my_id:
+                        foreign_count += 1
+                        continue
+                    all_videos.append({
+                        "video": video,
+                        "from_id": item.get("from_id", 0),
+                        "date": item.get("date", video.get("date", 0)),
+                        "message_text": "",
+                    })
+
+            cursor = data.get("cursor", "")
+            if not cursor:
+                break
+            time.sleep(0.34)
+
+        if foreign_count:
+            self.progress.increment_foreign(foreign_count)
+
+        return all_videos
+
+    def _collect_videos_fallback(
+        self, peer_id: int, existing: list[dict], start_from: str,
+    ) -> tuple[list[dict], int]:
+        cursor: Optional[str] = start_from or None
+        foreign_count = 0
+        while not self._stop_requested:
+            params: dict = {
+                "peer_id": peer_id, "media_type": "video",
+                "count": 200, "preserve_order": 1,
+            }
+            if cursor:
+                params["start_from"] = cursor
+            resp = self.api.messages.getHistoryAttachments(**params)
+            items = resp.get("items", [])
+            cursor = resp.get("next_from")
+            if not items:
+                break
+            for item in items:
+                att = item.get("attachment", {})
+                if att.get("type") != "video":
+                    continue
+                video = att["video"]
+                if video.get("owner_id") != self._my_id:
+                    foreign_count += 1
+                    continue
+                existing.append({
+                    "video": video,
+                    "from_id": item.get("from_id", 0),
+                    "date": item.get("date", video.get("date", 0)),
+                    "message_text": "",
+                })
+            if not cursor:
+                break
+            time.sleep(0.34)
+        return existing, foreign_count
+
+    # -- выбор лучшего качества --
+
+    @staticmethod
+    def _best_video_url(files: dict) -> Optional[tuple[str, str]]:
+        """Выбирает URL видео максимального качества.
+
+        Возвращает (url, quality) или None.
+        """
+        for quality in VIDEO_QUALITY_PRIORITY:
+            url = files.get(quality)
+            if url:
+                return (url, quality)
+        return None
+
+    # -- скачивание одного видео --
+
+    def _download_single(
+        self, video_data: dict, files: dict,
+    ) -> Optional[VideoMeta]:
+        """Скачивает одно видео через прямой URL. Возвращает VideoMeta или None."""
+        video = video_data["video"]
+        video_id = video.get("id", 0)
+        date_ts: int = video_data.get("date", video.get("date", 0))
+        title = video.get("title", "")
+        duration = video.get("duration", 0)
+
+        best = self._best_video_url(files)
+        if not best:
+            self.progress.increment_no_files()
+            return None
+
+        url, quality = best
+
+        # Путь: downloads_video/video_{id}_{date}_{title}.mp4
+        dt = datetime.fromtimestamp(date_ts) if date_ts else datetime.now()
+        safe_title = self._safe_name(title)[:50] if title else ""
+        suffix = f"_{safe_title}" if safe_title else ""
+        filename = f"video_{video_id}_{dt.strftime('%Y%m%d_%H%M%S')}{suffix}.mp4"
+        filepath = self.download_dir / filename
+
+        if filepath.exists():
+            return None
+
+        # Скачиваем с retry и стримингом (128 КБ чанки)
+        file_size = 0
+        for attempt in range(config.MAX_RETRIES):
+            try:
+                resp = self._http.get(
+                    url, timeout=config.VIDEO_DOWNLOAD_TIMEOUT, stream=True,
+                )
+                resp.raise_for_status()
+
+                with open(filepath, "wb") as f:
+                    for chunk in resp.iter_content(chunk_size=131072):
+                        if self._stop_requested:
+                            f.close()
+                            filepath.unlink(missing_ok=True)
+                            return None
+                        f.write(chunk)
+
+                file_size = filepath.stat().st_size
+                break
+            except (requests.RequestException, OSError) as exc:
+                filepath.unlink(missing_ok=True)
+                if attempt < config.MAX_RETRIES - 1:
+                    time.sleep(2 ** attempt)
+                else:
+                    tqdm.write(f"    Ошибка скачивания ({filename}): {exc}")
+                    return None
+
+        # Метаданные
+        sender_id = video_data.get("from_id", 0)
+        sender_name = (
+            self._user_cache.get(sender_id, f"id{sender_id}")
+            if sender_id else ""
+        )
+
+        info = VideoMeta(
+            video_id=video_id,
+            owner_id=video.get("owner_id", 0),
+            title=title,
+            duration=duration,
+            date=date_ts,
+            sender_id=sender_id,
+            sender_name=sender_name,
+            message_text=video_data.get("message_text", ""),
+            quality=quality,
+        )
+
+        # Дата файла = дата сообщения
+        if date_ts:
+            os.utime(filepath, (date_ts, date_ts))
+
+        return info
+
+    # -- обработка одного диалога --
+
+    def _process_dialog(
+        self, peer_id: int, dialog_name: str, bar: tqdm,
+    ) -> None:
+        saved = self.progress.get_current_dialog()
+        resuming = saved is not None and saved.get("peer_id") == peer_id
+
+        if not resuming:
+            self.progress.set_current_dialog(peer_id)
+
+        # Сбор только моих видео
+        raw_videos = self._collect_my_videos(peer_id)
+        if not raw_videos:
+            if not self._stop_requested:
+                self.progress.mark_dialog_completed(peer_id)
+            return
+
+        # Дедупликация по video_id
+        seen: set[int] = set()
+        unique: list[dict] = []
+        for v in raw_videos:
+            vid = v["video"].get("id", 0)
+            if vid and vid not in seen:
+                seen.add(vid)
+                unique.append(v)
+
+        # Фильтруем уже скачанные
+        tasks = [
+            v for v in unique
+            if not self.progress.is_video_downloaded(v["video"].get("id", 0))
+        ]
+        skipped = len(unique) - len(tasks)
+
+        tqdm.write(
+            f"  [{dialog_name}] Моих видео: {len(unique)}, "
+            f"скачать: {len(tasks)}, пропустить: {skipped}"
+        )
+
+        if not tasks:
+            if not self._stop_requested:
+                self.progress.mark_dialog_completed(peer_id)
+            return
+
+        # Получаем прямые URL через video.get (без браузерного UA)
+        tqdm.write(f"  [{dialog_name}] Получаю URL видеофайлов...")
+        video_keys: list[str] = []
+        for t in tasks:
+            v = t["video"]
+            key = f"{v.get('owner_id', 0)}_{v.get('id', 0)}"
+            ak = v.get("access_key", "")
+            if ak:
+                key += f"_{ak}"
+            video_keys.append(key)
+
+        details = self._video_get_raw(video_keys)
+        # Индекс: video_id → files
+        files_map: dict[int, dict] = {}
+        for d in details:
+            files_map[d["id"]] = d.get("files", {})
+
+        # Предзагрузка имён
+        sender_ids = list({t.get("from_id", 0) for t in tasks if t.get("from_id", 0)})
+        if sender_ids:
+            self._prefetch_user_names(sender_ids)
+
+        # Прогресс-бар
+        bar.reset(total=len(unique))
+        bar.n = skipped
+        bar.refresh()
+        bar.set_description(f"Видео ({dialog_name[:25]})")
+
+        # Последовательное скачивание
+        for task in tasks:
+            if self._stop_requested:
+                break
+            if not self._check_free_space():
+                tqdm.write("Остановка: мало места на диске.")
+                self._stop_requested = True
+                break
+
+            video_id = task["video"].get("id", 0)
+            files = files_map.get(video_id, {})
+
+            # Проверяем: внешнее видео (YouTube и т.д.)?
+            if "external" in files and not any(
+                k.startswith("mp4_") for k in files
+            ):
+                self.progress.increment_external()
+                bar.update(1)
+                self.progress.save()
+                continue
+
+            # Убираем служебные поля
+            files.pop("failover_host", None)
+            files.pop("hls_ondemand", None)
+            files.pop("dash_ondemand", None)
+            files.pop("external", None)
+
+            result = self._download_single(task, files)
+
+            if result is not None:
+                fsize = 0
+                dt = datetime.fromtimestamp(task.get("date", 0) or time.time())
+                safe_title = self._safe_name(task["video"].get("title", ""))[:50]
+                sfx = f"_{safe_title}" if safe_title else ""
+                fname = f"video_{video_id}_{dt.strftime('%Y%m%d_%H%M%S')}{sfx}.mp4"
+                fpath = self.download_dir / fname
+                if fpath.exists():
+                    fsize = fpath.stat().st_size
+
+                self.progress.mark_video_downloaded(video_id, fsize)
+                dur_str = self._format_duration(task["video"].get("duration", 0))
+                tqdm.write(
+                    f"    ✓ {task['video'].get('title', '')[:40]} "
+                    f"({dur_str}, {result.quality}, {self._format_size(fsize)})"
+                )
+            else:
+                if not files or not self._best_video_url(files):
+                    pass  # increment_no_files уже вызван в _download_single
+                else:
+                    self.progress.increment_errors()
+
+            bar.update(1)
+            self.progress.save()
+
+        if not self._stop_requested:
+            self.progress.mark_dialog_completed(peer_id)
+
+    # -- главный цикл --
+
+    def run(self) -> None:
+        tqdm.write("=" * 60)
+        tqdm.write("  Выгрузка СВОИХ видео из диалогов ВКонтакте")
+        tqdm.write("=" * 60)
+
+        if not config.VK_TOKEN:
+            tqdm.write("ОШИБКА: Заполни VK_TOKEN в config.py!")
+            sys.exit(1)
+
+        try:
+            me = self.api.users.get()[0]
+            self._my_id = me["id"]
+            my_name = f"{me['first_name']} {me['last_name']}"
+            tqdm.write(f"Авторизован как: {my_name} (id{self._my_id})")
+            tqdm.write(f"Скачиваю только видео с owner_id={self._my_id}")
+            self._user_cache[me["id"]] = my_name
+        except Exception as exc:
+            tqdm.write(f"ОШИБКА авторизации: {exc}")
+            sys.exit(1)
+
+        conversations = self._get_all_conversations()
+        self.progress.data["dialogs_total"] = len(conversations)
+        self.progress.save()
+
+        peer_ids = [c["peer_id"] for c in conversations]
+        tqdm.write("Загружаю имена собеседников...")
+        self._prefetch_user_names(peer_ids)
+
+        completed_ids = set(self.progress.data["dialogs_completed"])
+        remaining = [c for c in conversations if c["peer_id"] not in completed_ids]
+
+        current = self.progress.get_current_dialog()
+        if current:
+            cur_pid = current["peer_id"]
+            remaining = [c for c in remaining if c["peer_id"] != cur_pid]
+            for c in conversations:
+                if c["peer_id"] == cur_pid:
+                    remaining.insert(0, c)
+                    break
+
+        stats = self.progress.data["stats"]
+        tqdm.write(
+            f"\nПрогресс: {len(completed_ids)}/{len(conversations)} диалогов, "
+            f"{stats['videos_downloaded']} видео скачано, "
+            f"{stats['foreign_skipped']} чужих пропущено"
+        )
+        tqdm.write(f"Осталось: {len(remaining)} диалогов")
+        tqdm.write("-" * 60)
+
+        dialogs_bar = tqdm(
+            total=len(conversations),
+            initial=len(completed_ids),
+            desc="Диалоги",
+            unit=" диал",
+            position=0,
+            dynamic_ncols=True,
+        )
+        videos_bar = tqdm(
+            total=0,
+            desc="Видео",
+            unit=" видео",
+            position=1,
+            leave=False,
+            dynamic_ncols=True,
+        )
+
+        try:
+            for conv in remaining:
+                if self._stop_requested:
+                    break
+                peer_id = conv["peer_id"]
+                dialog_name = self._get_user_name(peer_id)
+                self._process_dialog(peer_id, dialog_name, videos_bar)
+                if not self._stop_requested:
+                    dialogs_bar.update(1)
+        finally:
+            videos_bar.close()
+            dialogs_bar.close()
+            self.progress.save()
+
+            stats = self.progress.data["stats"]
+            completed_count = len(self.progress.data["dialogs_completed"])
+            total_count = self.progress.data["dialogs_total"]
+
+            print("\n" + "=" * 60)
+            print("  Итого:")
+            print(f"    Моих видео скачано:     {stats['videos_downloaded']}")
+            print(f"    Чужих видео пропущено:  {stats['foreign_skipped']}")
+            ext = stats.get("external_saved", 0)
+            if ext:
+                print(f"    Внешних (YouTube и т.п.):{ext}")
+            nf = stats.get("no_files", 0)
+            if nf:
+                print(f"    Без файлов (удалены?):  {nf}")
+            print(f"    Ошибок:                 {stats['errors']}")
+            print(f"    Скачано:                {self._format_size(stats['bytes_downloaded'])}")
+            print(f"    Диалогов обработано:    {completed_count}/{total_count}")
+            if self._stop_requested:
+                print("\n  Остановлено. Запусти снова для продолжения.")
+            else:
+                print("\n  Все диалоги обработаны!")
+            print("=" * 60)
+
+
+# ---------------------------------------------------------------------------
+# Точка входа
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    downloader = VKVideoDownloader()
+    downloader.run()
+
+
+if __name__ == "__main__":
+    main()

process_photos.py

@@ -0,0 +1,797 @@
+#!/usr/bin/env python3
+"""
+Обработка скачанных фото: сквозная дедупликация и классификация.
+
+Все фото собираются из downloads/ (из всех диалогов), сортируются
+хронологически (самые старые первыми) и раскладываются в output/:
+  output/personal/      — личные фото людей
+  output/travel/        — путешествия, места
+  output/food/          — еда
+  output/screenshots/   — скриншоты переписок
+  output/_duplicates/   — дубликаты (оригинал = самое раннее фото)
+  output/_junk/         — мемы, стикеры
+  output/_review/       — неуверенная классификация, art, document
+
+Использование:
+    python process_photos.py run                 # Полная обработка
+    python process_photos.py run --limit 200     # Тест на 200 фото
+    python process_photos.py run --dry-run       # Без перемещения
+    python process_photos.py rollback            # Откатить всё назад
+    python process_photos.py stats               # Статистика
+"""
+
+import argparse
+import json
+import os
+import shutil
+import signal
+import sys
+from collections import defaultdict
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import imagehash
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+
+import config
+
+# ---------------------------------------------------------------------------
+# Константы
+# ---------------------------------------------------------------------------
+
+# Папки-категории в output/
+DEDUP_DIR: str = "_duplicates"
+JUNK_DIR: str = "_junk"
+REVIEW_DIR: str = "_review"
+
+# Описания категорий для CLIP
+CATEGORIES: dict[str, list[str]] = {
+    "personal": [
+        "a personal photograph of real people",
+        "a selfie photo of a person",
+        "a group photo of friends or family",
+        "a portrait photograph of a person",
+        "a candid photo of people at an event or party",
+    ],
+    "travel": [
+        "a landscape photograph of nature or scenery",
+        "a travel photograph of a famous place or landmark",
+        "a photograph of architecture or buildings",
+        "a cityscape or street photograph",
+        "a photograph from a vacation or trip",
+    ],
+    "food": [
+        "a photograph of food or a dish on a plate",
+        "a restaurant or cafe photograph",
+        "a cooking or baking photograph",
+    ],
+    "screenshots": [
+        "a screenshot of a mobile phone chat or text messages",
+        "a screenshot of a computer screen with interface",
+        "a screenshot of a social media post or webpage",
+    ],
+    "meme": [
+        "a meme image with text overlay and funny picture",
+        "a demotivational poster image with black border",
+        "a comic strip or cartoon panel with speech bubbles",
+        "an internet joke image with caption text",
+    ],
+    "sticker": [
+        "a small cartoon sticker on plain background",
+        "a simple emoji or emoticon image",
+        "a cartoon character sticker with transparent background",
+    ],
+    "art": [
+        "a digital art or illustration drawing",
+        "a hand-drawn painting or artwork",
+        "abstract colorful art image",
+    ],
+    "document": [
+        "a scanned printed document or text page",
+        "a photograph of a paper document",
+        "a handwritten note or letter photograph",
+    ],
+}
+
+# Куда перемещать каждую категорию
+KEEP_CATEGORIES: set[str] = {"personal", "travel", "food", "screenshots"}
+JUNK_CATEGORIES: set[str] = {"meme", "sticker"}
+REVIEW_CATEGORIES: set[str] = {"art", "document"}
+
+
+# ---------------------------------------------------------------------------
+# Утилиты
+# ---------------------------------------------------------------------------
+
+def popcount64(arr: np.ndarray) -> np.ndarray:
+    """Vectorized подсчёт единичных бит в массиве uint64."""
+    x = arr.astype(np.uint64)
+    x = x - ((x >> np.uint64(1)) & np.uint64(0x5555555555555555))
+    x = (x & np.uint64(0x3333333333333333)) + (
+        (x >> np.uint64(2)) & np.uint64(0x3333333333333333)
+    )
+    x = (x + (x >> np.uint64(4))) & np.uint64(0x0F0F0F0F0F0F0F0F)
+    return ((x * np.uint64(0x0101010101010101)) >> np.uint64(56)).astype(
+        np.int32
+    )
+
+
+def unique_dest(dest: Path) -> Path:
+    """Если файл с таким именем уже существует, добавляет суффикс _2, _3 и т.д."""
+    if not dest.exists():
+        return dest
+    stem = dest.stem
+    suffix = dest.suffix
+    parent = dest.parent
+    counter = 2
+    while True:
+        candidate = parent / f"{stem}_{counter}{suffix}"
+        if not candidate.exists():
+            return candidate
+        counter += 1
+
+
+# ---------------------------------------------------------------------------
+# Трекер прогресса
+# ---------------------------------------------------------------------------
+
+class ProgressTracker:
+    """Прогресс обработки с поддержкой возобновления."""
+
+    def __init__(self, filepath: str = config.PROCESS_PROGRESS_FILE) -> None:
+        self.filepath: Path = Path(filepath)
+        self.data: dict = self._load()
+
+    def _load(self) -> dict:
+        """Загружает прогресс из файла."""
+        if self.filepath.exists():
+            try:
+                with open(self.filepath, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, OSError):
+                pass
+        return {
+            "version": 2,
+            "hashed_files": {},
+            "classified_files": {},
+            "processed_files": [],
+        }
+
+    def save(self) -> None:
+        """Сохраняет прогресс (атомарная запись)."""
+        self.data["last_updated"] = datetime.now().isoformat()
+        tmp = self.filepath.with_suffix(".tmp")
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(self.data, f, ensure_ascii=False, indent=2)
+        tmp.replace(self.filepath)
+
+    def reset(self) -> None:
+        """Полный сброс прогресса."""
+        self.data = {
+            "version": 2,
+            "hashed_files": {},
+            "classified_files": {},
+            "processed_files": [],
+        }
+        self.save()
+
+
+# ---------------------------------------------------------------------------
+# Лог отката
+# ---------------------------------------------------------------------------
+
+class RollbackLog:
+    """Журнал перемещений для отката."""
+
+    def __init__(self, filepath: str = config.ROLLBACK_LOG_FILE) -> None:
+        self.filepath: Path = Path(filepath)
+        self.moves: list[dict] = self._load()
+
+    def _load(self) -> list[dict]:
+        if self.filepath.exists():
+            try:
+                with open(self.filepath, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, OSError):
+                pass
+        return []
+
+    def log_move(self, src: str, dst: str, reason: str) -> None:
+        """Записывает перемещение."""
+        self.moves.append({"src": src, "dst": dst, "reason": reason})
+        self._save()
+
+    def _save(self) -> None:
+        with open(self.filepath, "w", encoding="utf-8") as f:
+            json.dump(self.moves, f, ensure_ascii=False, indent=2)
+
+    def rollback(self) -> int:
+        """Откатить все перемещения (LIFO). Возвращает кол-во восстановленных."""
+        restored = 0
+        for move in tqdm(
+            reversed(self.moves), total=len(self.moves),
+            desc="Откат", unit=" файлов",
+        ):
+            current = Path(move["dst"])
+            original = Path(move["src"])
+            if current.exists():
+                try:
+                    original.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.move(str(current), str(original))
+                    restored += 1
+                except OSError as exc:
+                    tqdm.write(f"  Ошибка: {current.name}: {exc}")
+        self.moves.clear()
+        self._save()
+        return restored
+
+    @property
+    def count(self) -> int:
+        return len(self.moves)
+
+
+# ---------------------------------------------------------------------------
+# Основной обработчик
+# ---------------------------------------------------------------------------
+
+class PhotoProcessor:
+    """Сквозная обработка: сбор → сортировка → хеширование → деdup → CLIP → организация."""
+
+    def __init__(self, args: argparse.Namespace) -> None:
+        self.source_dir: Path = Path(args.source)
+        self.output_dir: Path = Path(args.output)
+        self.limit: Optional[int] = args.limit
+        self.threshold: int = args.threshold
+        self.dry_run: bool = args.dry_run
+        self._stop: bool = False
+
+        signal.signal(signal.SIGINT, self._signal_handler)
+        signal.signal(signal.SIGTERM, self._signal_handler)
+
+        self.progress = ProgressTracker()
+        self.rollback = RollbackLog()
+
+    def _signal_handler(self, _sig: int, _frame: object) -> None:
+        if self._stop:
+            tqdm.write("\nПринудительная остановка!")
+            sys.exit(1)
+        self._stop = True
+        tqdm.write("\nОстановка... сохраняю прогресс.")
+
+    # -- 1. Сбор и сортировка --
+
+    def _scan_photos(self) -> list[Path]:
+        """Собирает все фото из downloads/, сортирует по дате файла (oldest first)."""
+        photos: list[Path] = []
+        for root, _dirs, files in os.walk(self.source_dir):
+            for f in files:
+                if f.lower().endswith((".jpg", ".jpeg", ".png")):
+                    photos.append(Path(root) / f)
+
+        # Сортировка по mtime (= дата сообщения ВК, установлена через os.utime)
+        photos.sort(key=lambda p: p.stat().st_mtime)
+
+        if self.limit:
+            photos = photos[: self.limit]
+
+        return photos
+
+    # -- 2. Хеширование --
+
+    @staticmethod
+    def _compute_one_hash(photo_path: Path) -> Optional[tuple[str, str]]:
+        """Вычисляет pHash одного фото."""
+        try:
+            with Image.open(photo_path) as img:
+                h = imagehash.phash(img, hash_size=config.HASH_SIZE)
+                return (str(photo_path), str(h))
+        except Exception:
+            return None
+
+    def _compute_hashes(self, photos: list[Path]) -> dict[str, str]:
+        """Вычисляет хеши для всех фото (с кешем и многопоточностью)."""
+        cached: dict[str, str] = self.progress.data.get("hashed_files", {})
+        result: dict[str, str] = {}
+        to_hash: list[Path] = []
+
+        for p in photos:
+            key = str(p)
+            if key in cached:
+                result[key] = cached[key]
+            else:
+                to_hash.append(p)
+
+        if not to_hash:
+            tqdm.write(f"  Все {len(result)} хешей из кеша.")
+            return result
+
+        tqdm.write(f"  Хеширование: {len(to_hash)} новых + {len(result)} из кеша")
+
+        bar = tqdm(total=len(to_hash), desc="Хеширование", unit=" фото")
+        with ThreadPoolExecutor(max_workers=config.HASH_WORKERS) as executor:
+            futures = {
+                executor.submit(self._compute_one_hash, p): p
+                for p in to_hash
+            }
+            done_count = 0
+            for future in as_completed(futures):
+                if self._stop:
+                    for f in futures:
+                        f.cancel()
+                    break
+                res = future.result()
+                if res:
+                    path_str, hash_hex = res
+                    result[path_str] = hash_hex
+                    cached[path_str] = hash_hex
+                bar.update(1)
+                done_count += 1
+                if done_count % 500 == 0:
+                    self.progress.data["hashed_files"] = cached
+                    self.progress.save()
+        bar.close()
+
+        self.progress.data["hashed_files"] = cached
+        self.progress.save()
+        return result
+
+    # -- 3. Хронологическая дедупликация --
+
+    def _dedup_chronological(
+        self,
+        sorted_photos: list[Path],
+        hashes: dict[str, str],
+    ) -> tuple[list[Path], list[Path]]:
+        """Проходит фото от старых к новым. Первое вхождение — оригинал, остальные — дубликаты.
+
+        Возвращает (originals, duplicates).
+        """
+        # Массив уникальных хешей (int) для vectorized сравнения
+        unique_hash_ints: list[int] = []
+        unique_hash_np: Optional[np.ndarray] = None
+
+        originals: list[Path] = []
+        duplicates: list[Path] = []
+
+        tqdm.write(f"  Сквозная дедупликация (порог: {self.threshold})...")
+
+        for photo in tqdm(
+            sorted_photos, desc="Дедупликация", unit=" фото", leave=False,
+        ):
+            if self._stop:
+                break
+
+            key = str(photo)
+            hash_hex = hashes.get(key)
+            if hash_hex is None:
+                # Не удалось вычислить хеш — пропускаем
+                continue
+
+            hash_int = int(hash_hex, 16)
+
+            is_duplicate = False
+
+            if unique_hash_ints:
+                # Vectorized сравнение с уже встреченными уникальными хешами
+                if unique_hash_np is None or len(unique_hash_np) != len(unique_hash_ints):
+                    unique_hash_np = np.array(unique_hash_ints, dtype=np.uint64)
+
+                xor = np.bitwise_xor(np.uint64(hash_int), unique_hash_np)
+                distances = popcount64(xor)
+                if np.any(distances <= self.threshold):
+                    is_duplicate = True
+
+            if is_duplicate:
+                duplicates.append(photo)
+            else:
+                originals.append(photo)
+                unique_hash_ints.append(hash_int)
+                unique_hash_np = None  # Инвалидируем кеш numpy-массива
+
+        tqdm.write(
+            f"  Оригиналов: {len(originals)}, дубликатов: {len(duplicates)}"
+        )
+        return originals, duplicates
+
+    # -- 4. CLIP классификация --
+
+    def _classify_photos(
+        self, photos: list[Path],
+    ) -> dict[str, tuple[str, float]]:
+        """Классифицирует фото через CLIP. Возвращает {path_str: (category, score)}."""
+        import torch
+        import open_clip
+
+        cached: dict[str, list] = self.progress.data.get("classified_files", {})
+        result: dict[str, tuple[str, float]] = {}
+        to_classify: list[Path] = []
+
+        for p in photos:
+            key = str(p)
+            if key in cached:
+                result[key] = tuple(cached[key])
+            elif p.exists():
+                to_classify.append(p)
+
+        if not to_classify:
+            tqdm.write(f"  Все {len(result)} классификаций из кеша.")
+            return result
+
+        tqdm.write(f"  Классификация: {len(to_classify)} новых + {len(result)} из кеша")
+
+        # Устройство
+        if torch.backends.mps.is_available():
+            device = torch.device("mps")
+            tqdm.write("  Устройство: Apple Silicon MPS")
+        elif torch.cuda.is_available():
+            device = torch.device("cuda")
+        else:
+            device = torch.device("cpu")
+            tqdm.write("  Устройство: CPU")
+
+        # Загрузка модели
+        tqdm.write("  Загрузка CLIP ViT-B-32...")
+        model, _, preprocess = open_clip.create_model_and_transforms(
+            "ViT-B-32", pretrained="laion2b_s34b_b79k",
+        )
+        tokenizer = open_clip.get_tokenizer("ViT-B-32")
+        model = model.to(device)
+        model.eval()
+
+        # Подготовка text-эмбеддингов
+        all_prompts: list[str] = []
+        category_mapping: list[str] = []
+        for cat_name, prompts in CATEGORIES.items():
+            for prompt in prompts:
+                all_prompts.append(prompt)
+                category_mapping.append(cat_name)
+
+        tokens = tokenizer(all_prompts).to(device)
+        with torch.no_grad():
+            text_features = model.encode_text(tokens)
+            text_features /= text_features.norm(dim=-1, keepdim=True)
+
+        tqdm.write("  Модель загружена.")
+
+        # Классификация батчами
+        batch_size = config.CLIP_BATCH_SIZE
+        bar = tqdm(total=len(to_classify), desc="Классификация", unit=" фото")
+
+        for i in range(0, len(to_classify), batch_size):
+            if self._stop:
+                break
+
+            batch_paths = to_classify[i: i + batch_size]
+            tensors: list = []
+            valid_paths: list[Path] = []
+
+            for p in batch_paths:
+                try:
+                    img = Image.open(p).convert("RGB")
+                    tensors.append(preprocess(img))
+                    valid_paths.append(p)
+                except Exception:
+                    pass
+
+            if tensors:
+                image_batch = torch.stack(tensors).to(device)
+                with torch.no_grad():
+                    image_features = model.encode_image(image_batch)
+                    image_features /= image_features.norm(dim=-1, keepdim=True)
+                    similarities = image_features @ text_features.T
+
+                for j, path in enumerate(valid_paths):
+                    sims = similarities[j]
+                    cat_scores: dict[str, list[float]] = defaultdict(list)
+                    for idx, cat_name in enumerate(category_mapping):
+                        cat_scores[cat_name].append(sims[idx].item())
+
+                    cat_avg = {
+                        cat: sum(scores) / len(scores)
+                        for cat, scores in cat_scores.items()
+                    }
+                    best_cat = max(cat_avg, key=lambda k: cat_avg[k])
+                    best_score = cat_avg[best_cat]
+
+                    key = str(path)
+                    result[key] = (best_cat, best_score)
+                    cached[key] = [best_cat, best_score]
+
+            bar.update(len(batch_paths))
+
+            if (i // batch_size) % 10 == 0:
+                self.progress.data["classified_files"] = cached
+                self.progress.save()
+
+        bar.close()
+        self.progress.data["classified_files"] = cached
+        self.progress.save()
+        return result
+
+    # -- 5. Организация (перемещение) --
+
+    def _move_photo(
+        self, photo: Path, dest_dir: Path, reason: str,
+    ) -> Optional[Path]:
+        """Перемещает фото в dest_dir (плоско, без подпапок диалогов).
+
+        Возвращает путь назначения или None при dry-run.
+        """
+        dest = unique_dest(dest_dir / photo.name)
+
+        if self.dry_run:
+            tqdm.write(f"  [DRY-RUN] {photo.name} → {dest_dir.name}/")
+            return None
+
+        dest_dir.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(photo), str(dest))
+        self.rollback.log_move(str(photo), str(dest), reason)
+        return dest
+
+    def _organize_all(
+        self,
+        originals: list[Path],
+        duplicates: list[Path],
+        classifications: dict[str, tuple[str, float]],
+    ) -> dict[str, int]:
+        """Перемещает все фото в output/ по категориям (плоская структура)."""
+        stats: dict[str, int] = defaultdict(int)
+        confidence_min = config.CLIP_CONFIDENCE_MIN
+
+        # Дубликаты → output/_duplicates/
+        tqdm.write("Перемещение дубликатов...")
+        for photo in tqdm(duplicates, desc="Дубликаты", unit=" фото", leave=False):
+            if self._stop:
+                break
+            self._move_photo(photo, self.output_dir / DEDUP_DIR, "duplicate")
+            stats["duplicates"] += 1
+
+        # Оригиналы → по категориям
+        tqdm.write("Перемещение оригиналов по категориям...")
+        for photo in tqdm(originals, desc="Организация", unit=" фото", leave=False):
+            if self._stop:
+                break
+
+            key = str(photo)
+            cat_info = classifications.get(key)
+
+            if cat_info is None:
+                # Нет классификации — в review
+                self._move_photo(
+                    photo,
+                    self.output_dir / REVIEW_DIR / "unclassified",
+                    "unclassified",
+                )
+                stats["review_unclassified"] += 1
+                continue
+
+            category, score = cat_info
+
+            if score < confidence_min:
+                dest = self.output_dir / REVIEW_DIR / "low_confidence"
+                stats["review_low_conf"] += 1
+                reason = f"low_conf:{category}"
+            elif category in JUNK_CATEGORIES:
+                dest = self.output_dir / JUNK_DIR
+                stats[f"junk_{category}"] += 1
+                reason = f"junk:{category}"
+            elif category in REVIEW_CATEGORIES:
+                dest = self.output_dir / REVIEW_DIR / category
+                stats[f"review_{category}"] += 1
+                reason = f"review:{category}"
+            elif category in KEEP_CATEGORIES:
+                dest = self.output_dir / category
+                stats[f"keep_{category}"] += 1
+                reason = f"keep:{category}"
+            else:
+                dest = self.output_dir / REVIEW_DIR / "other"
+                stats["review_other"] += 1
+                reason = f"other:{category}"
+
+            self._move_photo(photo, dest, reason)
+
+        return dict(stats)
+
+    # -- Главная команда: run --
+
+    def run(self) -> None:
+        """Полная обработка: сбор → деdup → classify → организация."""
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        tqdm.write("=" * 60)
+        tqdm.write("  Обработка фото: дедупликация + классификация")
+        tqdm.write(f"  Источник: {self.source_dir}/")
+        tqdm.write(f"  Выход:    {self.output_dir}/")
+        tqdm.write("=" * 60)
+
+        # 1. Сбор фото, отсортированных по дате (oldest first)
+        tqdm.write("\n[1/5] Сбор и сортировка фото по дате...")
+        photos = self._scan_photos()
+        if not photos:
+            tqdm.write("Фото не найдено.")
+            return
+
+        oldest = datetime.fromtimestamp(photos[0].stat().st_mtime)
+        newest = datetime.fromtimestamp(photos[-1].stat().st_mtime)
+        tqdm.write(
+            f"  Найдено: {len(photos)} фото "
+            f"({oldest.strftime('%Y-%m-%d')} → {newest.strftime('%Y-%m-%d')})"
+        )
+
+        if self._stop:
+            return
+
+        # 2. Хеширование
+        tqdm.write("\n[2/5] Вычисление перцептивных хешей...")
+        hashes = self._compute_hashes(photos)
+        if self._stop:
+            return
+
+        # 3. Хронологическая дедупликация (от старых к новым)
+        tqdm.write("\n[3/5] Сквозная дедупликация (oldest = оригинал)...")
+        originals, duplicates = self._dedup_chronological(photos, hashes)
+        if self._stop:
+            return
+
+        # 4. Классификация оригиналов через CLIP
+        tqdm.write(f"\n[4/5] Классификация {len(originals)} оригиналов...")
+        classifications = self._classify_photos(originals)
+        if self._stop:
+            return
+
+        # 5. Перемещение в output/
+        tqdm.write(f"\n[5/5] Организация файлов в {self.output_dir}/...")
+        stats = self._organize_all(originals, duplicates, classifications)
+        self.progress.save()
+
+        # Итого
+        tqdm.write("\n" + "=" * 60)
+        tqdm.write("  Итого:")
+        total_keep = sum(v for k, v in stats.items() if k.startswith("keep_"))
+        total_junk = sum(v for k, v in stats.items() if k.startswith("junk_"))
+        total_review = sum(v for k, v in stats.items() if k.startswith("review_"))
+        total_dup = stats.get("duplicates", 0)
+
+        tqdm.write(f"    Оригиналов (keep):     {total_keep}")
+        for k, v in sorted(stats.items()):
+            if k.startswith("keep_"):
+                tqdm.write(f"      {k.replace('keep_', '')}: {v}")
+        tqdm.write(f"    Дубликатов:            {total_dup}")
+        tqdm.write(f"    Мусор (junk):          {total_junk}")
+        tqdm.write(f"    На проверку (review):  {total_review}")
+        tqdm.write(f"    Всего обработано:      {sum(stats.values())}")
+        tqdm.write("=" * 60)
+
+    # -- Откат --
+
+    def run_rollback(self) -> None:
+        """Откатывает все перемещения обратно в downloads/."""
+        tqdm.write("=" * 60)
+        tqdm.write("  Откат всех перемещений")
+        tqdm.write("=" * 60)
+
+        if self.rollback.count == 0:
+            tqdm.write("Нет перемещений для отката.")
+            return
+
+        tqdm.write(f"Записей в журнале: {self.rollback.count}")
+        restored = self.rollback.rollback()
+        tqdm.write(f"Восстановлено файлов: {restored}")
+
+        # Сбрасываем прогресс
+        self.progress.reset()
+
+        # Удаляем пустые папки в output/
+        if self.output_dir.exists():
+            self._remove_empty_dirs(self.output_dir)
+            if self.output_dir.exists() and not any(self.output_dir.iterdir()):
+                self.output_dir.rmdir()
+                tqdm.write(f"  Удалена пустая папка: {self.output_dir.name}/")
+
+    # -- Статистика --
+
+    def run_stats(self) -> None:
+        """Показывает статистику из отчёта."""
+        report_path = self.output_dir / "classification_report.json"
+        if not report_path.exists():
+            tqdm.write("Отчёт не найден. Сначала запусти run.")
+            return
+
+        with open(report_path, "r", encoding="utf-8") as f:
+            report = json.load(f)
+
+        tqdm.write("=" * 60)
+        tqdm.write("  Статистика обработки")
+        tqdm.write("=" * 60)
+        tqdm.write(f"Всего фото: {report.get('total_photos', '?')}")
+        tqdm.write(f"Дубликатов: {report.get('duplicates', '?')}")
+        tqdm.write(f"\nКатегории оригиналов:")
+        for cat, count in report.get("categories", {}).items():
+            marker = ""
+            if cat in KEEP_CATEGORIES:
+                marker = " [ОСТАВИТЬ]"
+            elif cat in JUNK_CATEGORIES:
+                marker = " [МУСОР]"
+            elif cat in REVIEW_CATEGORIES:
+                marker = " [ПРОВЕРИТЬ]"
+            total = report.get("originals", report.get("total_photos", 1))
+            pct = count * 100 / total if total else 0
+            tqdm.write(f"  {cat}: {count} ({pct:.1f}%){marker}")
+
+    # -- Утилиты --
+
+    @staticmethod
+    def _remove_empty_dirs(path: Path) -> None:
+        """Рекурсивно удаляет пустые подпапки."""
+        for child in sorted(path.rglob("*"), reverse=True):
+            if child.is_dir() and not any(child.iterdir()):
+                child.rmdir()
+
+
+# ---------------------------------------------------------------------------
+# Точка входа
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Сквозная дедупликация и классификация фото из ВК",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Примеры:
+  python process_photos.py run                      # Полная обработка
+  python process_photos.py run --limit 200          # Тест на 200 фото
+  python process_photos.py run --dry-run            # Без перемещения
+  python process_photos.py rollback                 # Откат
+  python process_photos.py stats                    # Статистика
+        """,
+    )
+    parser.add_argument(
+        "command",
+        choices=["run", "rollback", "stats"],
+        help="Команда: run | rollback | stats",
+    )
+    parser.add_argument(
+        "--source",
+        default=config.DOWNLOAD_DIR,
+        help=f"Папка с фото (по умолчанию: {config.DOWNLOAD_DIR})",
+    )
+    parser.add_argument(
+        "--output",
+        default=config.OUTPUT_DIR,
+        help=f"Папка для результатов (по умолчанию: {config.OUTPUT_DIR})",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Обработать только первые N фото (для тестирования)",
+    )
+    parser.add_argument(
+        "--threshold",
+        type=int,
+        default=config.DEDUP_THRESHOLD,
+        help=f"Порог Хэмминга (по умолчанию: {config.DEDUP_THRESHOLD})",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Показать без перемещения файлов",
+    )
+    args = parser.parse_args()
+
+    processor = PhotoProcessor(args)
+
+    if args.command == "run":
+        processor.run()
+    elif args.command == "rollback":
+        processor.run_rollback()
+    elif args.command == "stats":
+        processor.run_stats()
+
+
+if __name__ == "__main__":
+    main()