article-backup 0.3.1__tar.gz → 0.3.2__tar.gz

{article_backup-0.3.1 → article_backup-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: article-backup
-Version: 0.3.1
+Version: 0.3.2
 Summary: Локальный бэкап статей с Sponsr.ru и Boosty.to в Markdown с Hugo-интеграцией
 Author-email: Eugene Chaykin <eugene@chayk.in>
 License: Apache-2.0

{article_backup-0.3.1 → article_backup-0.3.2}/article_backup.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: article-backup
-Version: 0.3.1
+Version: 0.3.2
 Summary: Локальный бэкап статей с Sponsr.ru и Boosty.to в Markdown с Hugo-интеграцией
 Author-email: Eugene Chaykin <eugene@chayk.in>
 License: Apache-2.0

{article_backup-0.3.1 → article_backup-0.3.2}/article_backup.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ src/downloader.py
 src/sponsr.py
 src/utils.py
 tests/test_asset_dedup.py
+tests/test_boosty_normalize.py
 tests/test_incremental_sync.py
 tests/test_sponsr_normalize.py
 tests/test_sponsr_tags.py

{article_backup-0.3.1 → article_backup-0.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "article-backup"
-version = "0.3.1"
+version = "0.3.2"
 description = "Локальный бэкап статей с Sponsr.ru и Boosty.to в Markdown с Hugo-интеграцией"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{article_backup-0.3.1 → article_backup-0.3.2}/src/boosty.py

@@ -178,21 +178,54 @@ class BoostyDownloader(BaseDownloader):
         except json.JSONDecodeError:
             return ""
 
+        # Заголовок берётся из frontmatter (Hugo), не дублируем его в body.
+        # Inline-блоки (text, link) между BLOCK_END конкатенируются в один параграф.
+        # BLOCK_END завершает параграф. Block-level элементы разрывают параграф.
         lines: list[str] = []
+        current_paragraph: list[str] = []
+        paragraph_offset: int = 0
 
         for block in blocks:
-            md = self._block_to_markdown(block, asset_map)
-            if md:
+            block_type = block.get("type", "")
+            modificator = block.get("modificator", "")
+
+            # BLOCK_END завершает параграф
+            if modificator == "BLOCK_END":
+                if current_paragraph:
+                    lines.append("".join(current_paragraph))
+                    current_paragraph = []
+                lines.append("")
+                paragraph_offset = 0
+                continue
+
+            md = self._block_to_markdown(block, asset_map, paragraph_offset)
+            if not md:
+                continue
+
+            # Block-level элементы разрывают параграф
+            if block_type in ("image", "audio_file", "ok_video"):
+                if current_paragraph:
+                    lines.append("".join(current_paragraph))
+                    current_paragraph = []
                 lines.append(md)
+                paragraph_offset = 0
+            else:
+                # Inline-элементы (text, link) — в текущий параграф
+                current_paragraph.append(md)
+                paragraph_offset += self._block_text_length(block)
+
+        # Не забыть незавершённый параграф
+        if current_paragraph:
+            lines.append("".join(current_paragraph))
 
-        return "\n".join(lines)
+        return "\n".join(lines).strip() + "\n" if lines else ""
 
-    def _block_to_markdown(self, block: dict, asset_map: dict[str, str]) -> str:
+    def _block_to_markdown(self, block: dict, asset_map: dict[str, str], paragraph_offset: int = 0) -> str:
         """Конвертирует один блок в Markdown."""
         block_type = block.get("type", "")
 
         if block_type == "text":
-            return self._parse_text_block(block)
+            return self._parse_text_block(block, paragraph_offset)
 
         elif block_type == "image":
             url = block.get("url", "")
@@ -204,7 +237,7 @@ class BoostyDownloader(BaseDownloader):
 
         elif block_type == "link":
             url = block.get("url", "")
-            text = self._parse_text_block(block)
+            text = self._parse_text_block(block, paragraph_offset)
             if text and url:
                 return f"[{text}]({url})"
             elif url:
@@ -225,14 +258,15 @@ class BoostyDownloader(BaseDownloader):
 
         return ""
 
-    def _parse_text_block(self, block: dict) -> str:
-        """Парсит текстовый блок Boosty."""
+    def _parse_text_block(self, block: dict, paragraph_offset: int = 0) -> str:
+        """Парсит текстовый блок Boosty.
+        
+        Args:
+            block: Блок контента
+            paragraph_offset: Смещение начала блока в текущем параграфе (для коррекции стилей)
+        """
         content = block.get("content", "")
-        modificator = block.get("modificator", "")
-
-        # BLOCK_END — разделитель параграфов
-        if modificator == "BLOCK_END":
-            return "\n"
+        # BLOCK_END обрабатывается в _to_markdown, здесь он не нужен
 
         if not content:
             return ""
@@ -245,7 +279,14 @@ class BoostyDownloader(BaseDownloader):
 
                 # Применяем стили, если есть
                 if len(parsed) >= 3 and parsed[2]:
-                    text = self._apply_styles(text, parsed[2])
+                    styles = parsed[2]
+                    # Корректируем глобальные позиции стилей в локальные
+                    if paragraph_offset > 0:
+                        styles = [
+                            [s[0], s[1] - paragraph_offset, s[2]]
+                            for s in styles if len(s) >= 3
+                        ]
+                    text = self._apply_styles(text, styles)
 
                 return text
         except (json.JSONDecodeError, IndexError, TypeError):
@@ -253,6 +294,19 @@ class BoostyDownloader(BaseDownloader):
 
         return ""
 
+    def _block_text_length(self, block: dict) -> int:
+        """Возвращает длину сырого текста блока (до стилизации)."""
+        content = block.get("content", "")
+        if not content:
+            return 0
+        try:
+            parsed = json.loads(content)
+            if isinstance(parsed, list) and len(parsed) >= 1:
+                return len(str(parsed[0]))
+        except (json.JSONDecodeError, IndexError, TypeError):
+            pass
+        return 0
+
     def _apply_styles(self, text: str, styles: list) -> str:
         """Применяет стили к тексту (bold, italic)."""
         if not styles or not text:
@@ -276,10 +330,16 @@ class BoostyDownloader(BaseDownloader):
             fragment = result[start:end]
 
             # Типы стилей (примерные, на основе анализа)
-            if style_type == 1:  # bold
-                styled = f"**{fragment}**"
-            elif style_type == 2:  # italic
-                styled = f"*{fragment}*"
+            if style_type in (1, 2):
+                # Выносим пробелы наружу маркеров: "*текст *" → "*текст* "
+                stripped = fragment.strip()
+                if not stripped:
+                    styled = fragment  # только пробелы — не оборачиваем
+                else:
+                    leading = fragment[:len(fragment) - len(fragment.lstrip())]
+                    trailing = fragment[len(fragment.rstrip()):]
+                    marker = "**" if style_type == 1 else "*"
+                    styled = f"{leading}{marker}{stripped}{marker}{trailing}"
             elif style_type == 4:  # ссылка (обрабатывается в link блоках)
                 styled = fragment
             else:

{article_backup-0.3.1 → article_backup-0.3.2}/src/downloader.py

@@ -193,7 +193,19 @@ class BaseDownloader(ABC):
         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')
+        # RSS на уровне /{platform}/{author}/posts/ должен быть "про автора",
+        # а не про абстрактную секцию "Посты".
+        # title: author из config.yaml, description: display_name (если есть).
+        posts_title = self.source.author.replace('"', '\\"')
+        posts_desc = self.source.display_name or self.source.author
+        safe_posts_desc = posts_desc.replace('"', '\\"')
+        posts_index.write_text(
+            f'---\n'
+            f'title: "{posts_title}"\n'
+            f'description: "{safe_posts_desc}"\n'
+            f'---\n',
+            encoding='utf-8'
+        )
 
     def _save_post(self, post: Post):
         """Сохраняет пост на диск."""

article_backup-0.3.2/src/sponsr.py

@@ -0,0 +1,381 @@
+# 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,
+        existing_ids: set[str] | None = None,
+        incremental: bool = False,
+        safety_chunks: int = 1
+    ) -> list[dict]:
+        """
+        Получает список постов через API.
+        
+        Args:
+            existing_ids: Множество уже загруженных post_id (для инкрементального режима)
+            incremental: Включить инкрементальный режим
+            safety_chunks: Количество "защитных" чанков перед остановкой
+        """
+        project_id = self._get_project_id()
+        all_posts = []
+        offset = 0
+        clean_chunks_count = 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)
+
+            # Инкрементальный режим: проверяем, все ли посты уже существуют
+            if incremental and existing_ids is not None:
+                chunk_ids = {str(p.get('post_id')) for p in posts_chunk}
+                all_existing = chunk_ids.issubset(existing_ids)
+
+                if all_existing:
+                    clean_chunks_count += 1
+                    print(f"  Получено {offset}/{total} постов... (чанк уже скачан)")
+                    # Останавливаемся после safety_chunks + 1 (первый чистый + N защитных)
+                    if clean_chunks_count > safety_chunks:
+                        print(f"  ⚡ Остановлено на {offset} постах (все новые загружены)")
+                        break
+                else:
+                    clean_chunks_count = 0
+                    print(f"  Получено {offset}/{total} постов...")
+            else:
+                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.get('post_id') or raw_data.get('id'))
+        title = raw_data.get('post_title') or raw_data.get('title') or 'Без названия'
+        post_date = raw_data.get('post_date') or raw_data.get('date') or ''
+
+        # URL поста
+        post_url = raw_data.get('post_url') or f"/{self.source.author}/{post_id}/"
+        if post_url and not post_url.startswith('http'):
+            post_url = f"https://sponsr.ru{post_url}"
+
+        # HTML контент
+        content_obj = raw_data.get('post_text') or raw_data.get('text')
+        if isinstance(content_obj, dict):
+            content_html = content_obj.get('text', '')
+        elif isinstance(content_obj, str):
+            content_html = content_obj
+        else:
+            content_html = ''
+
+        # Теги - извлекаем только имена из объектов
+        tags_raw = raw_data.get('tags', [])
+        tags = []
+        if isinstance(tags_raw, list):
+            for tag in tags_raw:
+                if isinstance(tag, dict):
+                    # API может вернуть объект с полем tag_name или tag.tag_name
+                    tag_name = tag.get('tag_name') or tag.get('tag', {}).get('tag_name')
+                    if tag_name:
+                        tags.append(tag_name)
+                elif isinstance(tag, str):
+                    tags.append(tag)
+
+        # Извлекаем 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 _cleanup_html(self, html: str) -> str:
+        """Предобработка HTML перед конвертацией в Markdown."""
+        from bs4 import BeautifulSoup
+        
+        soup = BeautifulSoup(html, 'lxml')
+        
+        # Удаляем пустые теги форматирования (содержат только пробелы/пустые)
+        for tag in soup.find_all(['b', 'strong', 'em', 'i']):
+            text = tag.get_text()
+            if not text:
+                tag.decompose()
+            elif text.isspace():
+                tag.replace_with(text)
+        
+        return str(soup)
+
+    def _to_markdown(self, post: Post, asset_map: dict[str, str]) -> str:
+        """Конвертирует HTML в Markdown."""
+        if not post.content_html:
+            return ""
+
+        # Заменяем 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
+        html = self._cleanup_html(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)
+
+        # Удаляем bidi-маркеры, которые ломают пробелы рядом с текстом
+        markdown = re.sub(r'[\u200e\u200f\u202a-\u202e\u2066-\u2069]', '', markdown)
+
+        # Нормализуем неразрывные пробелы
+        markdown = re.sub(r'[\u00a0\u202f]', ' ', markdown)
+
+        # Склеиваем вложенные em/strong в жирный курсив
+        # html2text создаёт ** _текст_** или _**текст**_ для <b><em> (с пробелами)
+        markdown = re.sub(r'\*\*\s*_(.+?)_\s*\*\*', r'***\1***', markdown)
+        markdown = re.sub(r'_\s*\*\*(.+?)\*\*\s*_', r'***\1***', markdown)
+        
+        # Перемещаем форматирование внутрь ссылок
+        # [** _текст_**](url) → [***текст***](url)
+        markdown = re.sub(r'\[(\*{2,3})\s*(.+?)\s*(\*{2,3})\]\((.+?)\)', r'[\1\2\3](\4)', markdown)
+        # ***[текст](url)*** → [***текст***](url)
+        markdown = re.sub(r'(\*{2,3})\[(.+?)\]\((.+?)\)\1', r'[\1\2\1](\3)', markdown)
+        # _[текст](url)_ → [_текст_](url)
+        markdown = re.sub(r'_\[(.+?)\]\((.+?)\)_', r'[_\1_](\2)', markdown)
+
+        # Убираем лишние пробелы, добавленные html2text рядом с Unicode-кавычками
+        # Открывающие: « „ " '
+        markdown = re.sub(r'([\u00ab\u201e\u201c\u2018])\s+', r'\1', markdown)
+        # Закрывающие: » " '
+        markdown = re.sub(r'\s+([\u00bb\u201d\u2019])', r'\1', markdown)
+
+        # Восстанавливаем пробелы вокруг форматирования и ссылок
+        def _fix_spacing(text: str, pattern: re.Pattern) -> str:
+            """Добавляет пробелы вокруг элементов, если их нет."""
+            parts = []
+            last = 0
+            for match in pattern.finditer(text):
+                start, end = match.span()
+                before = text[last:start]
+                
+                # Добавляем пробел слева, если нужно
+                if start > 0 and before and before[-1].isalnum():
+                    before = before + ' '
+                
+                parts.append(before)
+                
+                # Добавляем сам матч
+                matched_text = text[start:end]
+                
+                # Добавляем пробел справа, если нужно
+                if end < len(text) and text[end].isalnum():
+                    matched_text = matched_text + ' '
+                
+                parts.append(matched_text)
+                last = end
+
+            parts.append(text[last:])
+            return ''.join(parts)
+
+        # Восстанавливаем пробелы вокруг bold-italic, bold, ссылок
+        markdown = _fix_spacing(markdown, re.compile(r'\*\*\*.+?\*\*\*'))
+        markdown = _fix_spacing(markdown, re.compile(r'(?<!\*)\*\*(?!\*).+?(?<!\*)\*\*(?!\*)'))
+        markdown = _fix_spacing(markdown, re.compile(r'\[[^\]]+\]\([^)]+\)'))
+
+        # Заголовок берётся из frontmatter (Hugo), не дублируем его в body.
+        return markdown