Upload 6 files

README.md

@@ -1,14 +1,65 @@
----
-title: Ranobelib Me To Epub
-emoji: 🐨
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 5.15.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: 'Конвертация любых ранобе с сайта Ranobelib.me в epub формат '
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Конвертер ранобэ с сайта ranobelib.me в EPUB
+
+Попробовать в онлайне: [Демонстрация на Hugging Face Spaces](https://huggingface.co/spaces/рыба)
+
+Данный проект позволяет автоматически собирать тома и главы ранобэ с сайта **ranobelib.me** и конвертировать их в удобный формат EPUB.  
+Все скачанные главы и изображения сохраняются в локальную папку `output`, а итоговый файл в формате EPUB также кладётся в эту же директорию (либо в поддиректорию, в зависимости от настроек).
+
+## Особенности
+- Поддержка Python от **3.9** до **3.11** (рекомендуется 3.10).
+- Сохранение иллюстраций в высоком качестве.
+- Создаётся структурированное оглавление.
+- EPUB-файлы совместимы с большинством читалок (Calibre, FBReader и т.д.).
+- Удобный web-интерфейс на базе **Gradio**.
+
+## Установка и запуск
+
+1. **Убедитесь, что установлен Python 3.9–3.11**  
+   Проверить версию Python можно так:
+   ```bash
+   python --version
+   ```
+   Если у вас несколько версий Python, используйте `python3` или `py -3`, в зависимости от вашей ОС.
+
+2. **Клонируйте репозиторий или скачайте архив с кодом**  
+   ```bash
+   git clone https://github.com/ВАШ_РЕПО/ranobe-epub-converter.git
+   cd ranobe-epub-converter
+   ```
+
+3. **Создайте и активируйте виртуальное окружение** (рекомендуется для изоляции зависимостей):
+   ```bash
+   python -m venv venv
+   ```
+   Активация виртуального окружения:
+   - **Windows**:  
+     ```bash
+     venv\Scripts\activate
+     ```
+   - **Linux/Mac**:  
+     ```bash
+     source venv/bin/activate
+     ```
+
+4. **Установите зависимости**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+5. **Запустите приложение**:
+   ```bash
+   python app.py
+   ```
+   После этого в консоли появится адрес, по которому будет доступен web-интерфейс (обычно `http://127.0.0.1:7860`).
+
+## Использование
+
+1. Перейдите в браузере по адресу, который вы увидите в консоли (например, http://127.0.0.1:7860).
+2. Вставьте ссылку на ранобэ с `ranobelib.me` в текстовое поле.
+3. Нажмите «Получить EPUB» и дождитесь завершения.
+4. Готовый EPUB-файл появится в поле «Выходные файлы» и будет также сохранён в директорию `output/<случайный_id>`.
+
+## Где искать скачанные данные?
+
+- **Папка `output`** в корне проекта — все загруженные изображения и главы сохраняются в ней.  
+- Для каждой новой конвертации создаётся отдельная подпапка по случайному UUID (например, `output/123e4567-e89b-12d3-a456-426614174000`), чтобы избежать конфликтов при множественных загрузках.

app.py

@@ -0,0 +1,76 @@
+import gradio as gr
+from pipeline import run_pipeline
+import os
+import urllib3
+from uuid import uuid4
+
+def process_url(url):
+    try:
+        # Проверяем что это ranobelib.me
+        if not url.startswith("https://ranobelib.me"):
+            return None, "Ошибка: Принимаются только ссылки с ranobelib.me"
+            
+        random_folder = str(uuid4())
+        # create output folder
+        output_dir = f'output/{random_folder}'
+        os.makedirs(output_dir, exist_ok=True)
+
+        output_path = run_pipeline(url, output_dir=output_dir,progress=gr.Progress())
+        
+        # Если файл создан успешно, возвращаем его и сообщение в статус
+        if os.path.exists(output_path):
+            return output_path, f"EPUB создан успешно: {output_path}"
+        else:
+            return None, "Ошибка: Файл не был создан"
+            
+    except Exception as e:
+        raise e
+        return None, f"Ошибка: {str(e)}"
+
+# Создаем интерфейс
+with gr.Blocks() as demo:
+    gr.Markdown("""
+    # Конвертер ранобэ с сайта ranobelib.me в EPUB
+    
+    Удобный инструмент для создания электронных книг из любимых ранобэ. Программа автоматически соберет все тома и главы в единый EPUB-файл.
+    
+    ### Инструкция:
+    1. Скопируйте ссылку на ранобэ с сайта **ranobelib.me**
+    2. Вставьте её в поле ввода ниже
+    3. Нажмите кнопку "Получить Epub" и дождитесь завершения конвертации
+    
+    ### Пример ссылки:
+    ```
+    https://ranobelib.me/ru/book/88265--kurasu-no-daikiraina-joshi-to-kekkon-suru-koto-ni-natta
+    ```
+    
+    ### Особенности:
+    - Работает только с сайтом **ranobelib.me**
+    - Время конвертации зависит от размера произведения
+    - В готовый файл включаются:
+      - Структурированное оглавление
+      - Все иллюстрации в высоком качестве
+      - Текст в удобном для чтения формате
+    - EPUB-файл совместим со всеми современными читалками
+    """)
+    status_bar = gr.Label(label="Статус")
+
+    with gr.Row():
+        with gr.Column():
+            url_input = gr.Textbox(
+                label="URL ранобэ",
+                placeholder="Вставьте ссылку на ранобэ с Ranobelib.me"
+            )
+        with gr.Column():
+            output_files = gr.Files(label="Выходные файлы")
+            convert_btn = gr.Button("Получить Epub")
+    
+    
+    convert_btn.click(
+        fn=process_url,
+        inputs=url_input,
+        outputs=[output_files,status_bar]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

create_epub.py

@@ -0,0 +1,385 @@
+import os
+import json
+import logging
+import io
+from pathlib import Path
+from ebooklib import epub
+from collections import defaultdict
+from bs4 import BeautifulSoup  # для поиска <img src="imgs/...">
+from PIL import Image
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler()]
+)
+
+class EpubCreator:
+    def __init__(self, ranobe_json_path, image_quality=85):
+        """
+        :param ranobe_json_path: путь к ranobe.json
+        :param image_quality: качество JPEG, по умолч. 85
+        """
+        self.ranobe_path = Path(ranobe_json_path)
+        if not self.ranobe_path.exists():
+            raise FileNotFoundError(f"Нет файла {ranobe_json_path}")
+
+        self.base_dir = self.ranobe_path.parent
+        self.image_quality = image_quality
+        self._image_cache = {}  # кэш сжатых изображений
+
+        with open(self.ranobe_path, "r", encoding="utf-8") as f:
+            self.ranobe_data = json.load(f)
+
+        self.book = epub.EpubBook()
+
+    def create_epub(self):
+        """
+        Создаём EPUB:
+          1) Обложка (при наличии),
+          2) Титульная страница,
+          3) Главы (группируем по томам),
+          4) Сохраняем.
+        """
+        # Метаданные
+        self.book.set_identifier(f"ranobe_{self.ranobe_data['id']}")
+        self.book.set_title(self.ranobe_data['title'])
+        self.book.set_language("ru")
+
+        # CSS
+        style_item = self._create_style()
+        self.book.add_item(style_item)
+
+        spine = ["nav"]
+        toc = []
+
+        # Обложка
+        if self.ranobe_data.get("cover_image"):
+            cover_fullpath = self.base_dir / self.ranobe_data["cover_image"]
+            if cover_fullpath.exists():
+                try:
+                    # Создаём страницу cover.xhtml
+                    cover_page = epub.EpubHtml(
+                        title="Cover",
+                        file_name="cover.xhtml",
+                        content='<div style="text-align:center;"><img src="images/cover.jpg" alt="cover" /></div>'
+                    )
+                    cover_page.add_item(style_item)
+                    self.book.add_item(cover_page)
+
+                    # Добавляем в spine
+                    spine.insert(0, cover_page)
+
+                    # Сжимаем и делаем set_cover
+                    cov_data = self._compress_image(cover_fullpath)
+                    self.book.set_cover("images/cover.jpg", cov_data)
+                except Exception as e:
+                    logging.warning(f"Не удалось обработать обложку: {e}")
+
+        # Титульная страница
+        title_page = self._make_title_page(style_item)
+        self.book.add_item(title_page)
+        spine.append(title_page)
+        toc.append(title_page)
+
+        # Группируем главы по томам
+        volumes_map = defaultdict(list)
+        for ch in self.ranobe_data["chapters"]:
+            volumes_map[ch["volume"]].append(ch)
+
+        # Сортируем ключи "томов" как числа, но если вдруг не число - как строку
+        def _vol_key(v):
+            try:
+                return float(v)
+            except:
+                return v
+
+        sorted_vols = sorted(volumes_map.keys(), key=_vol_key)
+
+        volumes_for_toc = []
+
+        for vol in sorted_vols:
+            vol_title = f"Том {vol}"
+            vol_filename = f"volume_{vol}.xhtml"
+            vol_content_parts = [f'<h2 id="volume_{vol}">{vol_title}</h2>']
+            chapters_toc = []
+
+            # Сортируем главы по номеру
+            chapters = sorted(volumes_map[vol], key=lambda c: float(c["chapter"]))
+            for cinfo in chapters:
+                ch_id = cinfo["id"]
+                ch_title = f"Глава {cinfo['chapter']} - {cinfo['name']}"
+                anchor = f"chapter_{ch_id}"
+
+                vol_content_parts.append(f'<h3 id="{anchor}">{ch_title}</h3>')
+
+                # Обрабатываем контент 
+                chapter_html = self._process_chapter_content(
+                    cinfo["content"],
+                    cinfo.get("attachments", [])
+                )
+                vol_content_parts.append(chapter_html)
+
+                chapters_toc.append((anchor, ch_title))
+
+            # Создаём EpubHtml для всего тома
+            vol_html = epub.EpubHtml(
+                title=vol_title,
+                file_name=vol_filename,
+                content="\n".join(vol_content_parts)
+            )
+            vol_html.add_item(style_item)
+            self.book.add_item(vol_html)
+            spine.append(vol_html)
+
+            volumes_for_toc.append((vol_title, vol_filename, chapters_toc))
+
+        # Формируем многоуровневое TOC
+        for (v_title, v_fname, chap_list) in volumes_for_toc:
+            vol_section = epub.Section(v_title, v_fname)
+            subitems = []
+            for (anchor, ch_title) in chap_list:
+                href = f"{v_fname}#{anchor}"
+                link_item = epub.Link(href, ch_title, f"chap_{anchor}")
+                subitems.append(link_item)
+            toc.append((vol_section, subitems))
+
+        self.book.toc = toc
+        self.book.spine = spine
+        self.book.add_item(epub.EpubNav())
+        self.book.add_item(epub.EpubNcx())
+
+        # Сохраняем
+        out_name = f"{self.ranobe_data['title']}.epub"
+        out_path = self.base_dir / out_name
+        epub.write_epub(str(out_path), self.book, {})
+        logging.info(f"EPUB создан: {out_path}")
+        return str(out_path)
+
+    def _process_chapter_content(self, content, attachments):
+        """
+        content может быть:
+          - строка HTML
+          - объект типа {"type": "doc", ...} (ProseMirror-формат)
+          - что-то ещё (None и т.д.)
+        Если doc-формат, конвертируем в HTML через _doc_to_html.
+        Далее создаём BeautifulSoup, ищем <img src="imgs/...">,
+        сжимаем и добавляем в EPUB, подменяя src="images/...".
+        """
+        # 1) Если контент - строка (HTML)
+        if isinstance(content, str):
+            raw_html = content
+        # 2) Если контент - dict (doc-формат)
+        elif isinstance(content, dict) and content.get("type") == "doc":
+            raw_html = self._doc_to_html(content, attachments)
+        else:
+            # не знаем, что это, вернём пустую строку
+            return ""
+
+        # Теперь обрабатываем получившийся HTML
+        soup = BeautifulSoup(raw_html, "html.parser")
+        all_imgs = soup.find_all("img")
+        for tag in all_imgs:
+            old_src = tag.get("src")
+            if not old_src:
+                continue
+            if old_src.startswith("imgs/"):
+                local_file = self.base_dir / old_src  # "output/imgs/filename.jpg" и т.п.
+                if local_file.exists():
+                    # Сжать + добавить
+                    new_data = self._compress_image(local_file)
+                    new_filename = "images/" + os.path.basename(local_file)
+                    # Добавляем в книгу
+                    item = epub.EpubItem(
+                        uid=f"img_{os.path.basename(old_src)}",
+                        file_name=new_filename,
+                        media_type="image/jpeg",
+                        content=new_data
+                    )
+                    self.book.add_item(item)
+
+                    # Меняем src
+                    tag["src"] = new_filename
+                else:
+                    logging.warning(f"Файл {local_file} не найден, пропускаем.")
+        return str(soup)
+
+    def _doc_to_html(self, doc_content, attachments):
+        """
+        Конвертация ProseMirror-формата (doc) в простой HTML.
+        attachments - список вложений, где filename соответствует "image".
+        
+        Пример структуры:
+          {
+            "type": "doc",
+            "content": [
+              {"type": "paragraph", "content": [{"type": "text","text":"..."}]},
+              {"type": "image", "attrs": {"images": [{"image":"xxxx"}]}},
+              ...
+            ]
+          }
+        
+        Нужно:
+         - paragraph -> <p>текст</p>
+         - image -> <img src="imgs/файл-из-attachments" />
+         - если встречаются другие типы, игнорируем или обрабатываем как абзац.
+        """
+        if doc_content.get("type") != "doc":
+            return ""
+
+        content_arr = doc_content.get("content", [])
+        html_parts = []
+
+        # Для быстрого доступа: "имяБезРасширения" -> attachment["filename"]
+        #   или просто сделаем словарь   image_name -> filename
+        name_map = {}
+        for att in attachments:
+            # Обычно att["filename"] = "8a57f2de.jpg"
+            # а в doc-е:   "image": "8a57f2de-df06-4a20-93af-a6e721fedfb2"
+            # Нужно сопоставить, часто это совпадает с `att["filename"]` без расширения,
+            # но бывает точное совпадение. Подгоняем логику по�� вашу структуру.
+            
+            # Если "images":[{"image":"17b9f599-efc3-4bee-8d15-9ad24da9dfac"}]
+            # тогда ищем attachment, у которого filename = "17b9f599-efc3-4bee-8d15-9ad24da9dfac.jpg"
+            base_name = os.path.splitext(att["filename"])[0]  # "17b9f599-efc3-4bee-8d15-9ad24da9dfac"
+            name_map[base_name] = att["filename"]
+
+        for node in content_arr:
+            ntype = node.get("type")
+
+            # 1) Абзац
+            if ntype == "paragraph":
+                paragraph_text = ""
+                if "content" in node:
+                    for inline in node["content"]:
+                        if inline.get("type") == "text":
+                            paragraph_text += inline.get("text", "")
+                if paragraph_text.strip():
+                    html_parts.append(f"<p>{paragraph_text}</p>")
+
+            # 2) Изображение
+            elif ntype == "image":
+                # атрибуты лежат в node["attrs"]["images"]
+                # это массив вида [{"image":"8a57f2de-df06-4a20-93af-a6e721fedfb2"}]
+                images_list = node.get("attrs", {}).get("images", [])
+                for img_obj in images_list:
+                    img_name = img_obj.get("image")  # "8a57f2de-df06-4a20-93af-a6e721fedfb2"
+                    if not img_name:
+                        continue
+                    # Сопоставляем с attachments
+                    filename = name_map.get(img_name)
+                    if filename:
+                        html_parts.append(f'<img src="imgs/{filename}"/>')
+                    else:
+                        # Если нет в attachments, пропустим
+                        logging.warning(f"Не нашли attachment для {img_name}")
+            
+            # 3) Любой другой тип (table, heading, list и пр.) - можно дописать по надобности
+            else:
+                # пока просто игнорируем или можно сделать ещё один <p>?
+                pass
+
+        return "\n".join(html_parts)
+
+    def _compress_image(self, img_path):
+        """
+        Сжимаем (конвертируем) в JPEG, используем кэш, чтобы не обрабатывать повторно.
+        """
+        if img_path in self._image_cache:
+            return self._image_cache[img_path]
+
+        try:
+            with Image.open(img_path) as im:
+                if im.mode != "RGB":
+                    im = im.convert("RGB")
+                buf = io.BytesIO()
+                im.save(buf, format="JPEG", optimize=True, quality=self.image_quality)
+                buf.seek(0)
+                data = buf.read()
+                self._image_cache[img_path] = data
+                return data
+        except Exception as e:
+            logging.warning(f"Ошибка сжатия {img_path}: {e}")
+            return img_path.read_bytes()
+
+    def _make_title_page(self, style_item):
+        title = self.ranobe_data.get("title", "Без названия")
+        orig = self.ranobe_data.get("original_title", "")
+        desc = self.ranobe_data.get("description", "")
+
+        # Ссылка "Далее" -> первый том
+        volumes = [ch["volume"] for ch in self.ranobe_data["chapters"]]
+        link = "#"
+        if volumes:
+            try:
+                first_vol = sorted(volumes, key=lambda x: float(x))[0]
+                link = f"volume_{first_vol}.xhtml#volume_{first_vol}"
+            except:
+                pass
+
+        html = f"""
+        <h1 style="text-align:center;">{title}</h1>
+        <h2 style="text-align:center;">{orig}</h2>
+        <h3>Описание</h3>
+        <p>{desc}</p>
+        <p style="text-align:center;">
+          <a href="{link}" style="font-size:1.2em;">Далее &raquo;</a>
+        </p>
+        <h3>Содержание</h3>
+        <p>Используйте оглавление или кнопку &laquo;Далее&raquo;.</p>
+        """
+        page = epub.EpubHtml(
+            title="Титульная страница",
+            file_name="title_page.xhtml",
+            content=html
+        )
+        page.add_item(style_item)
+        return page
+
+    def _create_style(self):
+        css = '''
+        @namespace epub "http://www.idpf.org/2007/ops";
+        body {
+            font-family: Arial, sans-serif;
+            line-height: 1.6;
+            margin: 0 auto;
+            max-width: 800px;
+        }
+        h1, h2, h3 {
+            text-align: center;
+            margin: 1em 0;
+        }
+        p {
+            margin: 0.5em 0;
+            text-indent: 1.5em;
+        }
+        img {
+            display: block;
+            margin: 1em auto;
+            max-width: 100%;
+        }
+        '''
+        style_item = epub.EpubItem(
+            uid="main_style",
+            file_name="style/main.css",
+            media_type="text/css",
+            content=css
+        )
+        return style_item
+
+def main():
+    print("Введите путь к ranobe.json:")
+    path = input().strip()
+    if not os.path.exists(path):
+        print("Файл не найден!")
+        return
+    try:
+        creator = EpubCreator(path, image_quality=85)
+        epub_file = creator.create_epub()
+        print(f"Готово! EPUB: {epub_file}")
+    except Exception as e:
+        logging.error(f"Ошибка: {e}")
+        print(f"Ошибка: {e}")
+
+if __name__ == "__main__":
+    main()

get_ranobe_content.py

@@ -0,0 +1,310 @@
+import logging
+import os
+import json
+import time
+from pathlib import Path
+import requests
+from tqdm import tqdm
+from bs4 import BeautifulSoup  # чтобы заменить ссылки прямо в HTML
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[logging.StreamHandler()]
+)
+
+def extract_book_id(url):
+    """
+    Извлекаем ID книги из URL (например /ru/book/1234--kniga, /ru/1234--kniga).
+    Возвращаем '1234--kniga' или None, если не получилось.
+    """
+    import re
+    patterns = [
+        r'/ru/book/(\d+--[\w-]+)',
+        r'/ru/(\d+--[\w-]+)/',
+    ]
+    for pat in patterns:
+        m = re.search(pat, url)
+        if m:
+            return m.group(1)
+    return None
+
+def get_book_info(book_id):
+    """
+    Получаем инфо о книге (название, описание).
+    """
+    api_url = f"https://api2.mangalib.me/api/manga/{book_id}?fields[]=summary"
+    r = requests.get(api_url)
+    if r.status_code == 200:
+        return r.json().get('data', {})
+    return None
+
+def get_cover_url(book_id):
+    """
+    Получаем URL обложки.
+    """
+    api_url = f"https://api2.mangalib.me/api/manga/{book_id}"
+    r = requests.get(api_url)
+    if r.status_code == 200:
+        data = r.json().get('data', {})
+        cover_data = data.get('cover', {})
+        return cover_data.get('default')
+    return None
+
+def get_chapters_list(book_id):
+    """
+    Получаем список глав: [ {"tom": int, "chapter": float, "name": str, "id": int}, ... ]
+    """
+    api_url = f"https://api2.mangalib.me/api/manga/{book_id}/chapters"
+    r = requests.get(api_url)
+    if r.status_code == 200:
+        data = r.json().get('data', [])
+        chapters = []
+        for ch in data:
+            chapters.append({
+                "tom": int(ch['volume']),
+                "chapter": float(ch['number']),
+                "name": ch['name'],
+                "id": ch['id']
+            })
+        chapters.sort(key=lambda x: (x['tom'], x['chapter']))
+        return chapters
+    return []
+
+def get_chapter_data(book_id, volume, chapter, max_retries=5, sleep_time=1):
+    """
+    Получаем контент и вложения главы. Возвращаем словарь или None.
+    Повторяем до max_retries раз с паузой в sleep_time секунд,
+    если сервер не вернул код 200.
+    """
+    if chapter.endswith('.0'):
+        chapter = chapter.split('.')[0]
+    api_url = f"https://api2.mangalib.me/api/manga/{book_id}/chapter?number={chapter}&volume={volume}"
+
+    for attempt in range(1, max_retries + 1):
+        try:
+            r = requests.get(api_url)
+            if r.status_code == 200:
+                return r.json().get('data')
+            else:
+                logging.warning(
+                    f"Не удалось загрузить главу (статус {r.status_code}), попытка {attempt}/{max_retries}"
+                )
+        except Exception as e:
+            logging.error(f"Ошибка при запросе главы: {e}")
+
+        if attempt < max_retries:
+            time.sleep(sleep_time)
+    # Если все попытки провалились, возвращаем None
+    return None
+
+def download_image(url, save_path, max_retries=5, sleep_time=1):
+    """
+    Скачиваем картинку, сохраняем в save_path.
+    Повторяем до max_retries раз с паузой в sleep_time секунд,
+    если сервер не вернул код 200 или возникла ошибка.
+    """
+    for attempt in range(1, max_retries + 1):
+        try:
+            if url.startswith("https://"):
+                resp = requests.get(url)
+            else:
+                # если url типа "/uploads/...":
+                resp = requests.get(f"https://ranobelib.me{url}")
+
+            if resp.status_code == 200:
+                os.makedirs(os.path.dirname(save_path), exist_ok=True)
+                with open(save_path, "wb") as f:
+                    f.write(resp.content)
+                return True
+            else:
+                logging.warning(
+                    f"Не удалось скачать {url}, код {resp.status_code}, попытка {attempt}/{max_retries}"
+                )
+        except Exception as e:
+            logging.error(f"Ошибка скачивания {url}: {e}")
+
+        if attempt < max_retries:
+            time.sleep(sleep_time)
+    return False
+
+def fix_img_links_in_html(html_str, output_folder):
+    """
+    На вход: исходный HTML (как строка), где могут быть <img loading="lazy" src="https://ranobelib.me/...">
+    Задача:
+      - ��айти все <img src="..."> (используем BeautifulSoup).
+      - Для каждого img, скачать локально (imgs/filename.jpg).
+      - Заменить src="..." на "imgs/filename.jpg".
+    Возвращаем новый HTML со всеми локальными ссылками.
+    """
+    soup = BeautifulSoup(html_str, "html.parser")
+    imgs = soup.find_all("img")
+    for tag in imgs:
+        # Удаляем loading="lazy", если не нужно
+        if 'loading' in tag.attrs:
+            del tag.attrs['loading']
+
+        src_val = tag.get("src")
+        if not src_val:
+            continue
+
+        if src_val.startswith("http") or src_val.startswith("/uploads/"):
+            # Извлекаем имя файла
+            from urllib.parse import urlparse, unquote
+            parsed = urlparse(src_val)
+            filename = os.path.basename(parsed.path)  # извлечём имя файла
+            if not filename:
+                filename = "img_unknown.jpg"
+
+            local_path = Path(output_folder) / "imgs" / filename
+            if download_image(src_val, local_path):
+                tag["src"] = f"imgs/{filename}"
+        # Иначе, если уже локальная, не трогаем.
+    return str(soup)
+
+def fix_img_links_in_doc(doc_data, output_folder, attachments):
+    """
+    Обработка контента в doc-формате (ProseMirror).
+    Зависит от структуры doc_data и attachments.
+    Здесь пример, где мы скачиваем файлы из attachments,
+    но не меняем напрямую сам doc (если ссылки на изображения
+    формируются автоматикой по имени).
+    """
+    for att in attachments:
+        url = att['url']
+        filename = att['filename']
+        local_path = Path(output_folder) / "imgs" / filename
+        download_image(url, local_path)
+    return doc_data
+
+def get_ranobe_content(book_url, output_dir="output",progress=None):
+    """
+    Основная функция:
+      1) Извлекаем book_id
+      2) Скачиваем инфо о книге, обложку
+      3) Получаем список глав
+      4) Для каждой главы: получаем контент, скачиваем картинки (прямо в тексте <img>),
+         attachments (тоже скачиваем), подменяем src="..." на локальное (imgs/...)
+      5) Сохраняем ranobe.json (все ссылки уже локальные).
+    """
+    # if progress:
+    progress(0, desc="Подготовка директорий")
+        
+    out_path = Path(output_dir)
+    out_path.mkdir(parents=True, exist_ok=True)
+    imgs_path = out_path / "imgs"
+    imgs_path.mkdir(exist_ok=True)
+
+    # if progress:
+    progress(0.05, desc="Получение информации о книге")
+        
+
+    book_id = extract_book_id(book_url)
+    if not book_id:
+        raise ValueError("Не удалось извлечь ID книги")
+
+    info = get_book_info(book_id)
+    if not info:
+        raise ValueError("Не удалось получить инфо о книге")
+
+    # if progress:
+    progress(0.1, desc="Загрузка обложки")
+        
+
+    # Скачиваем обложку
+    cover_local = None
+    cover_url = get_cover_url(book_id)
+    if cover_url:
+        cover_filename = "cover" + Path(cover_url).suffix
+        cover_full_path = imgs_path / cover_filename
+        if download_image(cover_url, cover_full_path):
+            cover_local = f"imgs/{cover_filename}"
+
+    # if progress:
+    progress(0.15, desc="Получение списка глав")
+        
+
+    # Получаем список глав
+    chapters_list = get_chapters_list(book_id)
+    logging.info(f"Найдено глав: {len(chapters_list)}")
+
+    all_chapters = []
+
+    # Используем progress.tqdm для отслеживания прогресса
+    if True:
+        chapters_iter = progress.tqdm(chapters_list, desc="Загрузка глав")
+    # else:
+    #     chapters_iter = tqdm(chapters_list, desc="Загрузка глав")
+        
+    for ch in chapters_iter:
+        tom = str(ch['tom'])
+        chap_str = str(ch['chapter'])
+        ch_data = get_chapter_data(book_id, tom, chap_str)
+        if not ch_data:
+            logging.warning(f"Пропускаем главу {tom} {chap_str} (не удалось загрузить).")
+            continue
+
+        attachments = ch_data.get("attachments", [])
+        content = ch_data.get("content", "")
+
+        # Если контент строковый (HTML)
+        if isinstance(content, str):
+            new_html = fix_img_links_in_html(content, out_path)
+            content = new_html
+        # Если контент doc-формат
+        elif isinstance(content, dict) and content.get("type") == "doc":
+            content = fix_img_links_in_doc(content, out_path, attachments)
+
+        # Скачиваем все attachments (часто совпадают с изображениями в тексте)
+        for att in attachments:
+            url = att["url"]
+            fname = att["filename"]
+            local_file = imgs_path / fname
+            download_image(url, local_file)
+
+        # Формируем запись о главе
+        chapter_rec = {
+            "id": ch_data["id"],
+            "volume": ch_data["volume"],
+            "chapter": ch_data["number"],
+            "name": ch_data["name"],
+            "attachments": attachments,
+            "content": content
+        }
+        all_chapters.append(chapter_rec)
+
+    # if progress:
+    progress(0.95, desc="Сохранение результатов")
+        
+
+    # Формируем итоговую структуру и сохраняем
+    ranobe_data = {
+        "id": book_id,
+        "title": info.get("rus_name", "Без названия"),
+        "original_title": info.get("name", ""),
+        "description": info.get("summary", ""),
+        "cover_image": cover_local,  # "imgs/cover.jpg" или None
+        "chapters": all_chapters
+    }
+
+    ranobe_json_path = out_path / "ranobe.json"
+    with open(ranobe_json_path, "w", encoding="utf-8") as f:
+        json.dump(ranobe_data, f, ensure_ascii=False, indent=2)
+    logging.info(f"Сохранён ranobe.json: {ranobe_json_path}")
+    
+    # if progress:
+    progress(1.0, desc="Готово")
+
+    return str(ranobe_json_path)
+
+def main():
+    url = input("Введите URL книги: ").strip()
+    try:
+        rjson = get_ranobe_content(url, output_dir="output")
+        print(f"Готово! Данные о книге в: {rjson}")
+    except Exception as e:
+        logging.error(f"Ошибка: {e}")
+        print(f"Ошибка: {e}")
+
+if __name__ == "__main__":
+    main()

pipeline.py

@@ -0,0 +1,50 @@
+import logging
+from get_ranobe_content import get_ranobe_content
+from create_epub import EpubCreator
+import gradio as gr
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler()
+    ]
+)
+
+def run_pipeline(book_url, output_dir="output", progress=None):
+    """
+    Запускает полный цикл:
+
+      1) Получение контента (get_ranobe_content)
+      2) Создание EPUB (create_epub)
+    Возвращает путь к созданному EPUB-файлу.
+    """
+
+    progress(0, desc="Начинаем обработку")
+    
+
+    # 1. Скачиваем данные ранобэ и картинки
+    progress(0.1, desc="Получение контента ранобэ")
+    ranobe_json_path = get_ranobe_content(book_url, output_dir=output_dir, progress=progress)
+    
+    progress(0.8, desc="Создание EPUB файла")
+    creator = EpubCreator(ranobe_json_path, image_quality=85)
+    epub_path = creator.create_epub()
+
+    progress(1.0, desc="Готово")
+    return epub_path
+
+def main():
+    """
+    Примерный вызов для полного конвейера:
+    python pipeline.py
+    """
+
+    url = input("Введите URL ранобэ (любой URL с сайта с ID книги): ").strip()
+    try:
+        epub_path = run_pipeline(url, output_dir="output")
+        print(f"Готово! EPUB создан в: {epub_path}")
+    except Exception as e:
+        print(f"Ошибка: {e}")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,3 @@
+ebooklib
+gradio
+beautifulsoup4