article-backup 0.1.0__py3-none-any.whl

src/downloader.py

@@ -0,0 +1,366 @@
+# src/downloader.py
+"""Базовый класс загрузчика и общая логика."""
+
+import hashlib
+import json
+import re
+import time
+from abc import ABC, abstractmethod
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from urllib.parse import urljoin, urlparse
+
+import requests
+from slugify import slugify
+
+from .config import Config, Source
+from .database import Database, PostRecord
+from .utils import (
+    ALLOWED_EXTENSIONS,
+    should_download_asset,
+    get_extension_from_content_type,
+    transliterate,
+    sanitize_filename,
+    extract_internal_links,
+)
+
+
+def retry_request(
+    func,
+    max_retries: int = 3,
+    base_delay: float = 1.0,
+    max_delay: float = 30.0,
+    backoff_factor: float = 2.0,
+):
+    """
+    Выполняет функцию с retry и exponential backoff.
+
+    Args:
+        func: Функция для выполнения (должна возвращать Response или вызывать исключение)
+        max_retries: Максимальное количество попыток
+        base_delay: Начальная задержка в секундах
+        max_delay: Максимальная задержка в секундах
+        backoff_factor: Множитель для увеличения задержки
+    """
+    last_exception = None
+    delay = base_delay
+
+    for attempt in range(max_retries):
+        try:
+            return func()
+        except requests.RequestException as e:
+            last_exception = e
+            # Не ретраим 4xx ошибки (кроме 429 Too Many Requests)
+            if hasattr(e, 'response') and e.response is not None:
+                if 400 <= e.response.status_code < 500 and e.response.status_code != 429:
+                    raise
+
+            if attempt < max_retries - 1:
+                time.sleep(delay)
+                delay = min(delay * backoff_factor, max_delay)
+
+    raise last_exception
+
+
+@dataclass
+class Post:
+    """Универсальная структура поста."""
+    post_id: str
+    title: str
+    content_html: str
+    post_date: str
+    source_url: str
+    tags: list[str]
+    assets: list[dict]
+
+
+class BaseDownloader(ABC):
+    """Базовый класс для загрузчиков."""
+
+    PLATFORM: str = ""
+    MAX_WORKERS: int = 5
+    TIMEOUT: tuple = (5, 30)
+
+    def __init__(self, config: Config, source: Source, db: Database):
+        self.config = config
+        self.source = source
+        self.db = db
+        self.session = requests.Session()
+        self._setup_session()
+
+    @abstractmethod
+    def _setup_session(self):
+        """Настройка сессии (cookies, headers)."""
+        pass
+
+    @abstractmethod
+    def fetch_posts_list(self) -> list[dict]:
+        """Получает список постов с API."""
+        pass
+
+    @abstractmethod
+    def fetch_post(self, post_id: str) -> Post | None:
+        """Получает один пост по ID."""
+        pass
+
+    @abstractmethod
+    def _parse_post(self, raw_data: dict) -> Post:
+        """Парсит сырые данные API в Post."""
+        pass
+
+    def sync(self):
+        """Синхронизирует все новые посты автора."""
+        print(f"[{self.PLATFORM}] Синхронизация {self.source.author}...")
+
+        self._create_index_files()
+
+        existing_ids = self.db.get_all_post_ids(self.PLATFORM, self.source.author)
+        posts = self.fetch_posts_list()
+
+        new_posts = [p for p in posts if str(p.get('id', p.get('post_id'))) not in existing_ids]
+        print(f"  Найдено постов: {len(posts)}, новых: {len(new_posts)}")
+
+        for raw_post in new_posts:
+            post = self._parse_post(raw_post)
+            if post:
+                self._save_post(post)
+
+        # Фиксим ссылки после скачивания всех постов
+        if new_posts:
+            print(f"  Фиксим внутренние ссылки...")
+            self.fix_internal_links()
+
+    def download_single(self, post_id: str):
+        """Скачивает один пост по ID."""
+        print(f"[{self.PLATFORM}] Скачивание поста {post_id}...")
+        post = self.fetch_post(post_id)
+        if post:
+            self._save_post(post)
+        else:
+            print(f"  Ошибка: пост {post_id} не найден")
+
+    def _create_index_files(self):
+        """Создаёт _index.md файлы для навигации Hugo."""
+        # Для платформы
+        platform_dir = self.config.output_dir / self.PLATFORM
+        platform_dir.mkdir(parents=True, exist_ok=True)
+        platform_index = platform_dir / "_index.md"
+        if not platform_index.exists():
+            platform_index.write_text(f"---\ntitle: {self.PLATFORM.title()}\n---\n", encoding='utf-8')
+
+        # Для автора
+        author_dir = platform_dir / self.source.author
+        author_dir.mkdir(parents=True, exist_ok=True)
+        author_index = author_dir / "_index.md"
+        display_name = self.source.display_name or self.source.author
+        safe_display_name = display_name.replace('"', '\\"')
+        author_index.write_text(f'---\ntitle: "{safe_display_name}"\n---\n', encoding='utf-8')
+
+        # Для posts
+        posts_dir = author_dir / "posts"
+        posts_dir.mkdir(parents=True, exist_ok=True)
+        posts_index = posts_dir / "_index.md"
+        posts_index.write_text(f'---\ntitle: "Посты"\n---\n', encoding='utf-8')
+
+    def _save_post(self, post: Post):
+        """Сохраняет пост на диск."""
+        slug = self._make_slug(post)
+        post_dir = self._get_post_dir(slug)
+        post_dir.mkdir(parents=True, exist_ok=True)
+
+        # Скачиваем assets
+        if self.source.download_assets and post.assets:
+            assets_dir = post_dir / "assets"
+            assets_dir.mkdir(exist_ok=True)
+            asset_map = self._download_assets(post.assets, assets_dir) or {}
+        else:
+            asset_map = {}
+
+        # Конвертируем в Markdown
+        content_md = self._to_markdown(post, asset_map)
+
+        # Создаём frontmatter
+        frontmatter = self._make_frontmatter(post)
+
+        # Записываем файл
+        md_path = post_dir / "index.md"
+        md_path.write_text(frontmatter + content_md, encoding='utf-8')
+
+        # Обновляем индекс
+        record = PostRecord(
+            platform=self.PLATFORM,
+            author=self.source.author,
+            post_id=post.post_id,
+            title=post.title,
+            slug=slug,
+            post_date=post.post_date,
+            source_url=post.source_url,
+            local_path=str(post_dir),
+            tags=json.dumps(post.tags, ensure_ascii=False),
+            synced_at=datetime.now(timezone.utc).isoformat(),
+        )
+        self.db.add_post(record)
+        print(f"  ✓ {post.title}")
+
+    def _make_slug(self, post: Post) -> str:
+        """Создаёт slug для папки поста."""
+        date_prefix = post.post_date[:10]
+        title_slug = transliterate(post.title)[:60]
+        return f"{date_prefix}-{title_slug}"
+
+    def _get_post_dir(self, slug: str) -> Path:
+        """Возвращает путь к папке поста."""
+        return (
+            self.config.output_dir
+            / self.PLATFORM
+            / self.source.author
+            / "posts"
+            / slug
+        )
+
+    def _make_frontmatter(self, post: Post) -> str:
+        """Создаёт YAML frontmatter."""
+        # Экранируем кавычки в заголовке
+        safe_title = post.title.replace('"', '\\"')
+
+        lines = [
+            "---",
+            f'title: "{safe_title}"',
+            f"date: {post.post_date}",
+            f"source: {post.source_url}",
+            f"author: {self.source.author}",
+            f"platform: {self.PLATFORM}",
+            f"post_id: {post.post_id}",
+        ]
+        if post.tags:
+            tags_str = json.dumps(post.tags, ensure_ascii=False)
+            lines.append(f"tags: {tags_str}")
+        lines.append("---\n\n")
+        return "\n".join(lines)
+
+    def _download_assets(self, assets: list[dict], assets_dir: Path) -> dict[str, str]:
+        """
+        Скачивает assets параллельно.
+        Возвращает маппинг {original_url: local_filename}.
+        """
+        asset_map = {}
+        used_filenames: set[str] = set()
+
+        def download_one(asset: dict) -> tuple[str, str | None]:
+            url = asset["url"]
+            try:
+                # Предварительная проверка только по расширению (если есть)
+                ext = Path(urlparse(url).path).suffix.lower()
+                if ext and ext not in ALLOWED_EXTENSIONS:
+                    return url, None
+
+                def do_request():
+                    resp = self.session.get(url, stream=True, timeout=self.TIMEOUT)
+                    resp.raise_for_status()
+                    return resp
+
+                response = retry_request(do_request, max_retries=3)
+
+                content_type = response.headers.get('Content-Type', '')
+
+                # Полная проверка после получения Content-Type
+                if not should_download_asset(url, content_type):
+                    return url, None
+
+                filename = self._make_asset_filename(url, content_type, asset.get('alt'))
+                filepath = assets_dir / filename
+
+                if not filepath.exists():
+                    with open(filepath, 'wb') as f:
+                        for chunk in response.iter_content(chunk_size=8192):
+                            f.write(chunk)
+
+                return url, filename
+            except requests.RequestException as e:
+                print(f"    Ошибка скачивания {url}: {e}")
+                return url, None
+
+        with ThreadPoolExecutor(max_workers=self.MAX_WORKERS) as executor:
+            futures = {executor.submit(download_one, a): a for a in assets}
+            for future in as_completed(futures):
+                url, filename = future.result()
+                if filename:
+                    # Дедупликация имён файлов
+                    if filename in used_filenames:
+                        filename = self._deduplicate_filename(filename, url)
+                    used_filenames.add(filename)
+                    asset_map[url] = filename
+
+        return asset_map
+
+    def _deduplicate_filename(self, filename: str, url: str) -> str:
+        """Создаёт уникальное имя файла добавляя хеш URL."""
+        path = Path(filename)
+        url_hash = hashlib.md5(url.encode()).hexdigest()[:8]
+        return f"{path.stem}-{url_hash}{path.suffix}"
+
+    def _make_asset_filename(self, url: str, content_type: str, alt: str | None) -> str:
+        """Создаёт имя файла для asset."""
+        path = urlparse(url).path
+        original_name = Path(path).name
+        ext = Path(path).suffix.lower()
+
+        if not ext or ext not in ALLOWED_EXTENSIONS:
+            ext = get_extension_from_content_type(content_type) or '.bin'
+
+        if alt:
+            name = transliterate(alt)[:50]
+        else:
+            name = slugify(Path(path).stem or 'asset', max_length=50)
+
+        return f"{name}{ext}"
+
+    def fix_internal_links(self):
+        """Фиксит внутренние ссылки во всех постах автора."""
+        posts = self.db.get_all_posts(self.PLATFORM, self.source.author)
+        if not posts:
+            return
+
+        # Строим маппинг post_id → slug
+        id_to_slug = {p.post_id: p.slug for p in posts}
+
+        fixed_files = 0
+
+        for post in posts:
+            md_path = Path(post.local_path) / "index.md"
+            if not md_path.exists():
+                continue
+
+            content = md_path.read_text(encoding='utf-8')
+
+            # Разделяем frontmatter и body
+            if content.startswith('---'):
+                parts = content.split('---', 2)
+                if len(parts) >= 3:
+                    frontmatter = parts[1]
+                    body = parts[2]
+                else:
+                    continue
+            else:
+                continue
+
+            original_body = body
+
+            for full_url, platform, post_id in extract_internal_links(body):
+                if post_id in id_to_slug:
+                    body = body.replace(full_url, f"../{id_to_slug[post_id]}/")
+
+            if body != original_body:
+                new_content = f"---{frontmatter}---{body}"
+                md_path.write_text(new_content, encoding='utf-8')
+                fixed_files += 1
+
+        if fixed_files:
+            print(f"    Исправлено ссылок в {fixed_files} файлах")
+
+    @abstractmethod
+    def _to_markdown(self, post: Post, asset_map: dict[str, str]) -> str:
+        """Конвертирует контент поста в Markdown."""
+        pass

src/sponsr.py

@@ -0,0 +1,257 @@
+# src/sponsr.py
+"""Загрузчик для Sponsr.ru"""
+
+import json
+import re
+from urllib.parse import urljoin
+
+import requests
+from bs4 import BeautifulSoup
+import html2text
+
+from .config import Config, Source, load_cookie
+from .database import Database
+from .downloader import BaseDownloader, Post
+
+# Паттерны для преобразования embed URL в watch URL
+VIDEO_EMBED_PATTERNS = [
+    (r'rutube\.ru/play/embed/([a-f0-9]+)', lambda m: f'https://rutube.ru/video/{m.group(1)}/'),
+    (r'youtube\.com/embed/([^/?]+)', lambda m: f'https://youtube.com/watch?v={m.group(1)}'),
+    (r'youtu\.be/([^/?]+)', lambda m: f'https://youtube.com/watch?v={m.group(1)}'),
+    (r'player\.vimeo\.com/video/(\d+)', lambda m: f'https://vimeo.com/{m.group(1)}'),
+    (r'ok\.ru/videoembed/(\d+)', lambda m: f'https://ok.ru/video/{m.group(1)}'),
+    (r'vk\.com/video_ext\.php\?.*?oid=(-?\d+).*?id=(\d+)', lambda m: f'https://vk.com/video{m.group(1)}_{m.group(2)}'),
+]
+
+
+class SponsorDownloader(BaseDownloader):
+    """Загрузчик статей с Sponsr.ru"""
+
+    PLATFORM = "sponsr"
+
+    def __init__(self, config: Config, source: Source, db: Database):
+        self._project_id: str | None = None
+        super().__init__(config, source, db)
+
+    def _setup_session(self):
+        """Настройка сессии с cookies."""
+        cookie = load_cookie(self.config.auth.sponsr_cookie_file)
+        self.session.headers.update({
+            'Cookie': cookie,
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            'X-Requested-With': 'XMLHttpRequest',
+        })
+
+    def _get_project_id(self) -> str:
+        """Получает project_id со страницы проекта."""
+        if self._project_id:
+            return self._project_id
+
+        url = f"https://sponsr.ru/{self.source.author}/"
+        response = self.session.get(url, timeout=self.TIMEOUT)
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, 'lxml')
+        data_tag = soup.find('script', id='__NEXT_DATA__')
+        if not data_tag:
+            raise ValueError(f"Не найден __NEXT_DATA__ на странице {url}")
+
+        data = json.loads(data_tag.string)
+        project_id = data.get('props', {}).get('pageProps', {}).get('project', {}).get('id')
+        if not project_id:
+            raise ValueError(f"Не найден project.id в __NEXT_DATA__")
+
+        self._project_id = str(project_id)
+        return self._project_id
+
+    def fetch_posts_list(self) -> list[dict]:
+        """Получает список всех постов через API."""
+        project_id = self._get_project_id()
+        all_posts = []
+        offset = 0
+
+        while True:
+            api_url = f"https://sponsr.ru/project/{project_id}/more-posts/?offset={offset}"
+            response = self.session.get(api_url, timeout=self.TIMEOUT)
+            response.raise_for_status()
+
+            data = response.json().get("response", {})
+            posts_chunk = data.get("rows", [])
+
+            if not posts_chunk:
+                break
+
+            all_posts.extend(posts_chunk)
+            offset = len(all_posts)
+
+            total = data.get("rows_count", 0)
+            print(f"  Получено {offset}/{total} постов...")
+
+        return all_posts
+
+    def fetch_post(self, post_id: str) -> Post | None:
+        """Получает один пост по ID."""
+        # Сначала пробуем получить напрямую со страницы поста
+        post = self._fetch_post_from_page(post_id)
+        if post:
+            return post
+
+        # Fallback: ищем в API постранично (без загрузки всего списка)
+        return self._find_post_in_api(post_id)
+
+    def _fetch_post_from_page(self, post_id: str) -> Post | None:
+        """Получает пост напрямую со страницы."""
+        # URL формат: https://sponsr.ru/{author}/{post_id}/...
+        url = f"https://sponsr.ru/{self.source.author}/{post_id}/"
+        try:
+            response = self.session.get(url, timeout=self.TIMEOUT)
+            response.raise_for_status()
+
+            soup = BeautifulSoup(response.text, 'lxml')
+            data_tag = soup.find('script', id='__NEXT_DATA__')
+            if not data_tag:
+                return None
+
+            data = json.loads(data_tag.string)
+            post_data = data.get('props', {}).get('pageProps', {}).get('post')
+            if not post_data:
+                return None
+
+            return self._parse_post(post_data)
+        except requests.RequestException:
+            return None
+
+    def _find_post_in_api(self, post_id: str) -> Post | None:
+        """Ищет пост в API постранично (останавливается при нахождении)."""
+        project_id = self._get_project_id()
+        offset = 0
+
+        while True:
+            api_url = f"https://sponsr.ru/project/{project_id}/more-posts/?offset={offset}"
+            try:
+                response = self.session.get(api_url, timeout=self.TIMEOUT)
+                response.raise_for_status()
+
+                data = response.json().get("response", {})
+                posts_chunk = data.get("rows", [])
+
+                if not posts_chunk:
+                    break
+
+                for raw_post in posts_chunk:
+                    if str(raw_post.get('post_id')) == post_id:
+                        return self._parse_post(raw_post)
+
+                offset += len(posts_chunk)
+            except requests.RequestException:
+                break
+
+        return None
+
+    def _parse_post(self, raw_data: dict) -> Post:
+        """Парсит сырые данные API в Post."""
+        post_id = str(raw_data['post_id'])
+        title = raw_data.get('post_title', 'Без названия')
+        post_date = raw_data.get('post_date', '')
+
+        # URL поста
+        post_url = raw_data.get('post_url', '')
+        if post_url and not post_url.startswith('http'):
+            post_url = f"https://sponsr.ru{post_url}"
+
+        # HTML контент
+        content_html = raw_data.get('post_text', '')
+
+        # Теги
+        tags = raw_data.get('tags', [])
+
+        # Извлекаем assets из HTML
+        assets = self._extract_assets(content_html)
+
+        return Post(
+            post_id=post_id,
+            title=title,
+            content_html=content_html,
+            post_date=post_date,
+            source_url=post_url,
+            tags=tags,
+            assets=assets,
+        )
+
+    def _extract_assets(self, html_content: str) -> list[dict]:
+        """Извлекает URL изображений из HTML."""
+        if not html_content:
+            return []
+
+        assets = []
+        soup = BeautifulSoup(html_content, 'lxml')
+
+        for img in soup.find_all('img'):
+            src = img.get('src') or img.get('data-src')
+            if not src:
+                continue
+
+            # Абсолютный URL
+            if not src.startswith('http'):
+                src = urljoin('https://sponsr.ru', src)
+
+            # Alt текст
+            alt = img.get('alt', '')
+            if not alt:
+                parent = img.find_parent('div', class_='post-image')
+                if parent and parent.get('data-alt'):
+                    alt = parent.get('data-alt')
+
+            assets.append({'url': src, 'alt': alt})
+
+        return assets
+
+    def _parse_video_url(self, embed_src: str) -> str | None:
+        """Преобразует embed URL в watch URL."""
+        for pattern, converter in VIDEO_EMBED_PATTERNS:
+            match = re.search(pattern, embed_src)
+            if match:
+                return converter(match)
+        # Fallback: вернуть оригинальный URL если не распознан
+        if embed_src and ('video' in embed_src or 'embed' in embed_src):
+            return embed_src
+        return None
+
+    def _replace_video_embeds(self, html_content: str) -> str:
+        """Заменяет iframe/embed видео на markdown-ссылки."""
+        soup = BeautifulSoup(html_content, 'lxml')
+
+        for iframe in soup.find_all(['iframe', 'embed']):
+            src = iframe.get('src', '')
+            video_url = self._parse_video_url(src)
+            if video_url:
+                placeholder = soup.new_tag('p')
+                placeholder.string = f'📹 Видео: {video_url}'
+                iframe.replace_with(placeholder)
+
+        return str(soup)
+
+    def _to_markdown(self, post: Post, asset_map: dict[str, str]) -> str:
+        """Конвертирует HTML в Markdown."""
+        if not post.content_html:
+            return f"# {post.title}\n\n"
+
+        # Заменяем URL изображений на локальные
+        html = post.content_html
+        for original_url, local_filename in asset_map.items():
+            html = html.replace(original_url, f"assets/{local_filename}")
+
+        # Заменяем iframe/embed видео на markdown-ссылки
+        html = self._replace_video_embeds(html)
+
+        # Конвертируем HTML в Markdown
+        h2t = html2text.HTML2Text()
+        h2t.ignore_links = False
+        h2t.ignore_images = False
+        h2t.body_width = 0  # Без переноса строк
+        h2t.unicode_snob = True
+
+        markdown = h2t.handle(html)
+
+        # Добавляем заголовок
+        return f"# {post.title}\n\n{markdown}"