Fix Pylint errors and refactor code

Author: Lysagxra

manga_downloader.py

@@ -1,18 +1,16 @@
 """A manga downloader and PDF generator for MangaWorld.
 
 This module allows you to download manga chapters from a given manga URL, process each
-chapter, and generate PDF files for the downloaded images. It utilizes `requests` for
-HTTP requests, `BeautifulSoup` for HTML parsing, and `rich` for displaying a progress
-bar during the download and conversion process.
+chapter, and generate PDF files for the downloaded images.
 """
 
 from __future__ import annotations
 
 import asyncio
 from pathlib import Path
 from typing import TYPE_CHECKING
-import aiohttp
 
+import aiohttp
 from rich.live import Live
 
 from src.config import DOWNLOAD_FOLDER, parse_arguments
@@ -21,24 +19,63 @@
     extract_download_links,
     extract_manga_type,
     extract_volume_info,
+    fetch_chapter_data,
 )
 from src.download_utils import download_chapter, run_in_parallel
-from src.crawler_utils import fetch_chapter_data
 from src.format_utils import extract_manga_info
 from src.general_utils import clear_terminal, fetch_page, validate_chapter_range
 from src.pdf_generator import generate_pdf_files
-from src.progress_utils import create_progress_bar, create_progress_table, create_select_items_list
+from src.progress_utils import (
+    create_progress_bar,
+    create_progress_table,
+    create_select_items_list,
+)
 
 if TYPE_CHECKING:
     from rich.progress import Progress
 
 
-def process_pdf_generation(manga_name: str, job_progress: Progress, single_pdf=False) -> None:
+def process_pdf_generation(
+    manga_name: str, job_progress: Progress, *, single_pdf: bool = False,
+) -> None:
     """Process the generation of PDF files for a specific manga."""
     manga_parent_folder = Path(DOWNLOAD_FOLDER) / manga_name
     generate_pdf_files(str(manga_parent_folder), job_progress, single_pdf=single_pdf)
 
 
+def download_chapter_with_progress(
+    manga_name: str,
+    download_links: list[str],
+    pages_per_chapter: list[int],
+    *,
+    generate_pdf: bool = False,
+    volume_name: str | None = None,
+) -> None:
+    """Download the chapters of a manga and displays a progress bar.
+
+    Optionally generate a PDF of the manga chapters if requested.
+    """
+    task_description = (
+        manga_name if volume_name is None else f"{manga_name} - {volume_name}"
+    )
+    working_path = manga_name if volume_name is None else f"{manga_name}/{volume_name}"
+
+    job_progress = create_progress_bar()
+    progress_table = create_progress_table(task_description, job_progress)
+
+    with Live(progress_table, refresh_per_second=10):
+        run_in_parallel(
+            download_chapter,
+            download_links,
+            job_progress,
+            pages_per_chapter,
+            working_path,
+        )
+        if generate_pdf:
+            single_pdf = volume_name is not None
+            process_pdf_generation(working_path, job_progress, single_pdf=single_pdf)
+
+
 async def process_manga_download(
     url: str,
     start_chapter: int | None = None,
@@ -54,37 +91,35 @@ async def process_manga_download(
 
     if volume_mode:
         volumes = extract_volume_info(soup)
-        volume_names = [v['name'] for v in volumes]
-        selected_indices = create_select_items_list(volume_names)
-        for idx in selected_indices:
-            volume = volumes[idx]
-            chapter_urls = [c['url'] for c in volume['chapters']]
+        volume_names = [volume["name"] for volume in volumes]
+        selected_indexes = create_select_items_list(volume_names)
+
+        for indx in selected_indexes:
+            volume = volumes[indx]
+            chapter_urls = [chapter["url"] for chapter in volume["chapters"]]
             pages_per_chapter = []
+
             async with aiohttp.ClientSession() as session:
                 tasks = [fetch_chapter_data(url, session) for url in chapter_urls]
                 results = await asyncio.gather(*tasks)
-                for result in results:
-                    pages_per_chapter.append(result[1] if result and result[1] else None)
+                pages_per_chapter = [
+                    result[1] if result and result[1] else None for result in results
+                ]
 
             download_links = await extract_download_links(
                 chapter_urls,
                 0,
                 len(chapter_urls),
                 manga_type,
             )
-            job_progress = create_progress_bar()
-            progress_table = create_progress_table(f"{manga_name} - {volume['name']}", job_progress)
-
-            with Live(progress_table, refresh_per_second=10):
-                run_in_parallel(
-                    download_chapter,
-                    download_links,
-                    job_progress,
-                    pages_per_chapter,
-                    f"{manga_name}/{volume['name']}"
-                )
-                if generate_pdf:
-                    process_pdf_generation(f"{manga_name}/{volume['name']}", job_progress, single_pdf=True)
+            download_chapter_with_progress(
+                manga_name,
+                download_links,
+                pages_per_chapter,
+                generate_pdf=generate_pdf,
+                volume_name=volume["name"],
+            )
+
     else:
         chapter_urls, pages_per_chapter = await extract_chapters_info(soup)
         start_index, end_index = validate_chapter_range(
@@ -98,28 +133,24 @@ async def process_manga_download(
             end_index,
             manga_type,
         )
-
-        job_progress = create_progress_bar()
-        progress_table = create_progress_table(manga_name, job_progress)
-
-        with Live(progress_table, refresh_per_second=10):
-            run_in_parallel(
-                download_chapter,
-                download_links,
-                job_progress,
-                pages_per_chapter[start_index:end_index],
-                manga_name,
-            )
-            if generate_pdf:
-                process_pdf_generation(manga_name, job_progress)
+        download_chapter_with_progress(
+            manga_name,
+            download_links,
+            pages_per_chapter[start_index:end_index],
+            generate_pdf=generate_pdf,
+        )
 
 
 async def main() -> None:
     """Initiate the manga download process from a given URL."""
     clear_terminal()
     args = parse_arguments()
     await process_manga_download(
-        args.url, start_chapter=args.start, end_chapter=args.end, generate_pdf=args.pdf, volume_mode=args.volume
+        args.url,
+        start_chapter=args.start,
+        end_chapter=args.end,
+        generate_pdf=args.pdf,
+        volume_mode=args.volume,
     )
 
 

src/config.py

@@ -21,6 +21,8 @@
 # ============================
 FIRST_PAGE_SUFFIX_REGEX = r"1\.(png|gif|jpg)$"
 MANGA_TYPE_REGEX = r'"typeT":\s*"([^"]*)"'
+COOKIE_REGEX = r'document\.cookie="([^;]+)'
+LINK_REGEX = r'location\.href="([^"]+)"'
 
 # ============================
 # Download Settings
@@ -39,10 +41,14 @@
 # ============================
 # Image Download Settings
 # ============================
-PAGE_EXTENSIONS = [".jpg", ".png", ".gif", ".webp"]  # List of supported image
-                                                     # extensions for download.
-ImageFile.LOAD_TRUNCATED_IMAGES = True               # Allow loading of truncated
-                                                     # images.
+# List of supported image extensions for download.
+PAGE_EXTENSIONS = [".jpg", ".png", ".gif", ".webp"]
+
+# List of supported image extensions for PDF generation.
+IMAGE_FORMATS_FOR_PDF = {".jpg", ".jpeg", ".png", ".webp", ".gif"}
+
+# Allow loading of truncated images.
+ImageFile.LOAD_TRUNCATED_IMAGES = True
 
 # ============================
 # HTTP / Network

src/crawler_utils.py

@@ -194,40 +194,54 @@ def extract_manga_type(soup: BeautifulSoup, manga_slug: str) -> str | None:
 
     return None
 
-def extract_volume_info(soup):
-    """
-    Extracts the volume list and relative list of chapter URLs.
+
+def extract_volume_info(soup: BeautifulSoup) -> list[dict]:
+    """Extract the volume list and relative list of chapter URLs.
+
     If a page doesn't contain volumes, it'll retrieve a volume with all chapters.
     Output:
         [
             {"name": "Volume 1", "chapters": [{"title": ..., "url": ...}, ...]},
             ...
         ]
     """
-    """Fetch the download link for the first image in a chapter page."""
     volumes = []
-    volume_elements = soup.find_all("div", class_="volume-element")
+    volume_elements = soup.find_all("div", {"class": "volume-element"})
+
     if volume_elements:
         for vol in volume_elements:
             # Volume name
-            name_tag = vol.find("p", class_="volume-name")
+            name_tag = vol.find("p", {"class": "volume-name"})
             volume_name = name_tag.get_text(strip=True) if name_tag else "Volume"
+
             # Volume chapters
             chapters = []
-            chapters_container = vol.find("div", class_="volume-chapters")
+            chapters_container = vol.find("div", {"class": "volume-chapters"})
+
             if chapters_container:
-                chapter_divs = chapters_container.find_all("div", class_="chapter")
+                chapter_divs = chapters_container.find_all("div", {"class": "chapter"})
+
                 for chap in chapter_divs:
-                    a_tag = chap.find("a", class_="chap", title=True)
+                    a_tag = chap.find("a", {"class": "chap"}, title=True)
                     if a_tag:
-                        chapters.append({
-                            "title": a_tag["title"],
-                            "url": a_tag["href"]
-                        })
+                        chapters.append(
+                            {
+                                "title": a_tag["title"],
+                                "url": a_tag["href"],
+                            },
+                        )
+
             if chapters:
-                volumes.append({"name": volume_name, "chapters": sorted(chapters, key=lambda c: c['title'])})
+                volumes.append(
+                    {
+                        "name": volume_name,
+                        "chapters": sorted(chapters, key=lambda chap: chap["title"]),
+                    },
+                )
+
     else:
         # No available volumes
         logging.error("The selected link doesn't have available volumes.")
         return None
-    return sorted(volumes, key=lambda v: v['name'])
+
+    return sorted(volumes, key=lambda vol: vol["name"])

src/general_utils.py

@@ -15,6 +15,8 @@
 from aiohttp import ClientSession
 from bs4 import BeautifulSoup
 
+from .config import COOKIE_REGEX, LINK_REGEX
+
 
 async def check_real_page(
     initial_response: BeautifulSoup,
@@ -29,8 +31,7 @@ async def check_real_page(
         and "document.cookie" in initial_response.body.script.text
     ):
         # Extract the cookie
-        cookie_regex = r'document\.cookie="([^;]+)'
-        match = re.search(cookie_regex, initial_response.body.script.text)
+        match = re.search(COOKIE_REGEX, initial_response.body.script.text)
 
         if match:
             cookie = match.group(1)
@@ -39,8 +40,7 @@ async def check_real_page(
             return initial_response
 
         # Extract the link
-        link_regex = r'location\.href="([^"]+)"'
-        match = re.search(link_regex, initial_response.body.script.text)
+        match = re.search(LINK_REGEX, initial_response.body.script.text)
 
         if match:
             link = match.group(1)  # Extracted link