web-novel-scraper 1.1.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

web_novel_scraper/novel_scraper.py

@@ -10,7 +10,8 @@ from .decode import Decoder
 from .file_manager import FileManager
 from . import utils
 
-from . import request_manager
+from .request_manager import get_html_content
+from .config_manager import ScraperConfig
 
 logger = logger_manager.create_logger('NOVEL SCRAPPING')
 
@@ -18,7 +19,6 @@ logger = logger_manager.create_logger('NOVEL SCRAPPING')
 @dataclass_json
 @dataclass
 class Metadata:
-    novel_title: str
     author: Optional[str] = None
     start_date: Optional[str] = None
     end_date: Optional[str] = None
@@ -105,10 +105,11 @@ class Chapter:
         return self.chapter_title < another.chapter_title
 
 
-@dataclass_json
+@dataclass_json(undefined=Undefined.EXCLUDE)
 @dataclass
 class Novel:
-    metadata: Metadata
+    metadata: Metadata = None
+    title: str = None
     scraper_behavior: ScraperBehavior = None
     chapters: list[Chapter] = field(default_factory=list)
     toc_main_url: Optional[str] = None
@@ -116,30 +117,23 @@ class Novel:
     host: str = None
 
     def __init__(self,
-                 novel_title: str = None,
+                 title: str,
                  toc_main_url: str = None,
                  toc_html: str = None,
                  chapters_url_list: list[str] = None,
                  metadata: Metadata = None,
                  chapters: list[Chapter] = None,
-                 novel_base_dir: str = None,
                  scraper_behavior: ScraperBehavior = None,
-                 host: str = None):
-
+                 host: str = None
+                 ):
         if toc_main_url and toc_html:
-            logger.error('There can only be one or toc_main_url or toc_html')
-            sys.exit(1)
+            logger.critical('There can only be one or toc_main_url or toc_html')
+            raise ValueError('There can only be one or toc_main_url or toc_html')
 
+        self.title = title
+        self.metadata = Metadata()
         if metadata is not None:
             self.metadata = metadata
-        elif novel_title is not None:
-            self.metadata = Metadata(novel_title)
-        else:
-            logger.error('You need to set "novel_title" or "metadata".')
-            sys.exit(1)
-
-        self.file_manager = FileManager(novel_title=self.metadata.novel_title,
-                                        novel_base_dir=novel_base_dir)
 
         if toc_html:
             self.file_manager.add_toc(toc_html)
@@ -155,9 +149,10 @@ class Novel:
             sys.exit(1)
 
         self.host = host if host else utils.obtain_host(self.toc_main_url)
-        self.decoder = Decoder(self.host)
 
-        self.save_novel()
+        self.config = None
+        self.file_manager = None
+        self.decoder = None
 
     def __str__(self):
         """
@@ -165,7 +160,7 @@ class Novel:
         """
         toc_info = self.toc_main_url if self.toc_main_url else "TOC added manually"
         attributes = [
-            f"Title: {self.metadata.novel_title}",
+            f"Title: {self.title}",
             f"Author: {self.metadata.author}",
             f"Language: {self.metadata.language}",
             f"Description: {self.metadata.description}",
@@ -177,30 +172,57 @@ class Novel:
         return (f"Novel Info: \n"
                 f"{attributes_str}")
 
+    @staticmethod
+    def load(title: str, cfg: ScraperConfig, novel_base_dir: str | None = None):
+        fm = FileManager(title, cfg.base_novels_dir, novel_base_dir, read_only=True)
+        raw = fm.load_novel_json()
+        if raw is None:
+            logger.debug(f'Novel "{title}" was not found.')
+            raise ValueError(f'Novel "{title}" was not found.')
+        novel = Novel.from_json(raw)
+        novel.config = cfg
+        novel.set_config(cfg=cfg, novel_base_dir=novel_base_dir)
+        return novel
+
     # NOVEL PARAMETERS MANAGEMENT
 
-    def set_scraper_behavior(self, **kwargs) -> None:
+    def set_config(self,
+                   cfg: ScraperConfig = None,
+                   config_file: str = None,
+                   base_novels_dir: str = None,
+                   novel_base_dir: str = None,
+                   decode_guide_file: str = None):
+        if cfg is not None:
+            self.config = cfg
+        else:
+            self.config = ScraperConfig(config_file=config_file,
+                                        base_novels_dir=base_novels_dir,
+                                        decode_guide_file=decode_guide_file)
+
+        self.file_manager = FileManager(title=self.title,
+                                        base_novels_dir=self.config.base_novels_dir,
+                                        novel_base_dir=novel_base_dir)
+
+        self.decoder = Decoder(self.host, self.config.decode_guide_file)
+
+    def set_scraper_behavior(self, save: bool = False, **kwargs) -> None:
         self.scraper_behavior.update_behavior(**kwargs)
-        self.save_novel()
 
     def set_metadata(self, **kwargs) -> None:
         self.metadata.update_behavior(**kwargs)
-        self.save_novel()
 
     def add_tag(self, tag: str) -> bool:
         if tag not in self.metadata.tags:
             self.metadata.tags.append(tag)
-            self.save_novel()
             return True
-        logger.warning(f'Tag "{tag}" already exists on novel {self.metadata.novel_title}')
+        logger.warning(f'Tag "{tag}" already exists on novel {self.title}')
         return False
 
     def remove_tag(self, tag: str) -> bool:
         if tag in self.metadata.tags:
             self.metadata.tags.remove(tag)
-            self.save_novel()
             return True
-        logger.warning(f'Tag "{tag}" doesn\'t exist on novel {self.metadata.novel_title}')
+        logger.warning(f'Tag "{tag}" doesn\'t exist on novel {self.title}')
         return False
 
     def set_cover_image(self, cover_image_path: str) -> bool:
@@ -208,10 +230,9 @@ class Novel:
 
     def set_host(self, host: str) -> None:
         self.host = host
-        self.decoder = Decoder(self.host)
-        self.save_novel()
+        self.decoder.set_host(host)
 
-    def save_novel(self) -> None:
+    def save_novel(self, save: bool = True) -> None:
         self.file_manager.save_novel_json(self.to_dict())
 
     # TABLE OF CONTENTS MANAGEMENT
@@ -224,7 +245,6 @@ class Novel:
             self.decoder = Decoder(self.host)
         elif update_host:
             self.decoder = Decoder(utils.obtain_host(self.toc_main_url))
-        self.save_novel()
 
     def add_toc_html(self, html: str, host: str = None) -> None:
         if self.toc_main_url:
@@ -236,13 +256,11 @@ class Novel:
             self.decoder = Decoder(self.host)
         self.file_manager.add_toc(html)
         # Delete toc_main_url since they are exclusive
-        self.save_novel()
 
     def delete_toc(self):
         self.file_manager.delete_toc()
         self.chapters = []
         self.chapters_url_list = []
-        self.save_novel()
 
     def sync_toc(self, reload_files: bool = False) -> bool:
         # Hard reload will request again the toc files from the toc_main_url
@@ -277,9 +295,17 @@ class Novel:
             if chapters_url_from_toc_content is None:
                 logger.error('Chapters url not found on toc_content')
                 return False
-            self.chapters_url_list = [*self.chapters_url_list,
-                                      *chapters_url_from_toc_content]
-        if self.scraper_behavior.auto_add_host:
+                # First we save a list of lists in case we need to invert the orderAdd commentMore actions
+            self.chapters_url_list.append(chapters_url_from_toc_content)
+
+        invert = self.decoder.is_index_inverted()
+        self.chapters_url_list = [
+            chapter
+            for chapters_url in (self.chapters_url_list[::-1] if invert else self.chapters_url_list)
+            for chapter in chapters_url
+        ]
+        add_host_to_chapter = self.scraper_behavior.auto_add_host or self.decoder.add_host_to_chapter()
+        if add_host_to_chapter:
             self.chapters_url_list = [
                 f'https://{self.host}{chapter_url}' for chapter_url in self.chapters_url_list]
         self.chapters_url_list = utils.delete_duplicates(
@@ -329,6 +355,7 @@ class Novel:
             chapter = self.chapters[chapter_idx]
         if update_html:
             logger.debug('HTML will be updated...')
+
         chapter = self._get_chapter(chapter,
                                     reload=update_html)
 
@@ -429,7 +456,7 @@ class Novel:
         return True
 
 
-# UTILS
+    ## UTILS
 
 
     def clean_files(self, clean_chapters: bool = True, clean_toc: bool = True, hard_clean: bool = False) -> None:
@@ -445,6 +472,9 @@ class Novel:
     def show_novel_dir(self) -> str:
         return self.file_manager.novel_base_dir
 
+
+    ## PRIVATE HELPERS
+
     def _clean_chapter(self, chapter_html_filename: str, hard_clean: bool = False) -> None:
         hard_clean = hard_clean or self.scraper_behavior.hard_clean
         chapter_html = self.file_manager.load_chapter_html(
@@ -464,6 +494,16 @@ class Novel:
             toc = self.decoder.clean_html(toc, hard_clean=hard_clean)
             self.file_manager.update_toc(toc, i)
 
+    def _request_html_content(self, url: str) -> Optional[str]:
+        request_config = self.decoder.request_config
+        force_flaresolver = request_config.get('force_flaresolver') or self.scraper_behavior.force_flaresolver
+        html_content = get_html_content(url,
+                                        retries=request_config.get('request_retries'),
+                                        timeout=request_config.get('request_timeout'),
+                                        time_between_retries=request_config.get('request_time_between_retries'),
+                                        force_flaresolver=force_flaresolver)
+        return html_content
+
     def _get_chapter(self,
                      chapter: Chapter,
                      reload: bool = False) -> Chapter | None:
@@ -481,8 +521,7 @@ class Novel:
                 return chapter
 
         # Fetch fresh content
-        chapter.chapter_html = request_manager.get_html_content(chapter.chapter_url,
-                                                                force_flaresolver=self.scraper_behavior.force_flaresolver)
+        chapter.chapter_html = self._request_html_content(chapter.chapter_url)
         if not chapter.chapter_html:
             logger.error(f'No content found on link {chapter.chapter_url}')
             return chapter
@@ -501,7 +540,11 @@ class Novel:
             if content:
                 return content
 
-        content = request_manager.get_html_content(url)
+        if utils.check_incomplete_url(url):
+            url = self.toc_main_url + url
+
+        # Fetch fresh content
+        content = self._request_html_content(url)
         if not content:
             logger.warning(f'No content found on link {url}')
             sys.exit(1)
@@ -579,13 +622,14 @@ class Novel:
         chapter_title = self.decoder.get_chapter_title(chapter.chapter_html)
         if not chapter_title:
             logger.debug('No chapter title found, generating one...')
-            chapter_title = f'{self.metadata.novel_title} Chapter {idx_for_chapter_name}'
+            chapter_title = f'{self.title} Chapter {idx_for_chapter_name}'
         chapter.chapter_title = str(chapter_title)
         logger.debug(f'Chapter title: "{chapter_title}"')
 
         logger.debug('Obtaining chapter content...')
+        save_title_to_content = self.scraper_behavior.save_title_to_content or self.decoder.save_title_to_content()
         chapter.chapter_content = self.decoder.get_chapter_content(chapter.chapter_html,
-                                                           self.scraper_behavior.save_title_to_content,
+                                                           save_title_to_content,
                                                            chapter.chapter_title)
         logger.debug('Chapter successfully decoded')
 
@@ -594,7 +638,7 @@ class Novel:
     def _create_epub_book(self, book_title: str = None, calibre_collection: dict = None) -> epub.EpubBook:
         book = epub.EpubBook()
         if not book_title:
-            book_title = self.metadata.novel_title
+            book_title = self.title
         book.set_title(book_title)
         book.set_language(self.metadata.language)
         book.add_metadata('DC', 'description', self.metadata.description)
@@ -679,11 +723,11 @@ class Novel:
         idx_start = start_chapter - 1
         idx_end = end_chapter
         # We create the epub book
-        book_title = f'{self.metadata.novel_title} Chapters {start_chapter} - {end_chapter}'
+        book_title = f'{self.title} Chapters {start_chapter} - {end_chapter}'
         calibre_collection = None
         # If collection_idx is set, we create a calibre collection
         if collection_idx:
-            calibre_collection = {'title': self.metadata.novel_title,
+            calibre_collection = {'title': self.title,
                                   'idx': str(collection_idx)}
         book = self._create_epub_book(book_title, calibre_collection)
 

web_novel_scraper/request_manager.py

@@ -4,6 +4,7 @@ from . import logger_manager
 from dotenv import load_dotenv
 import json
 import time
+from typing import Optional
 
 load_dotenv()
 
@@ -13,45 +14,52 @@ FORCE_FLARESOLVER = os.getenv('FORCE_FLARESOLVER', '0') == '1'
 
 logger = logger_manager.create_logger('GET HTML CONTENT')
 
-def get_request(url: str,
-                timeout: int = 20,
-                retries: int = 3,
-                time_between_retries: int = 1) -> requests.Response | None:
-    logger.debug(f'Starting get_request for {url} with timeout={timeout}, retries={retries}, time_between_retries={time_between_retries}')
+
+def _get_request(url: str,
+                 timeout: int,
+                 retries: int,
+                 time_between_retries: int) -> Optional[requests.Response]:
+    logger.debug(
+        f'Starting get_request for "{url}" with timeout={timeout}, '
+        f'retries={retries}, '
+        f'time_between_retries={time_between_retries}')
     for attempt in range(retries):
-        logger.debug(f'Attempt {attempt + 1} for {url}')
+        logger.debug(f'Attempt {attempt + 1} for "{url}"')
         try:
             response = requests.get(url, timeout=timeout)
             response.raise_for_status()
-            logger.debug(f'Successful response for {url} on attempt {attempt + 1}')
+            logger.debug(f'Successful response for "{url}" on attempt {attempt + 1}')
             return response
         except requests.exceptions.ConnectionError as e:
-            logger.error(f'Connection error ({attempt + 1}/{retries}): {e}')
+            logger.debug(f'Connection error ({attempt + 1}/{retries}): {e}')
         except requests.exceptions.Timeout as e:
-            logger.error(f'Request timed out ({attempt + 1}/{retries}): {e}')
+            logger.debug(f'Request timed out ({attempt + 1}/{retries}): {e}')
         except requests.exceptions.HTTPError as e:
-            logger.error(f'HTTP error ({attempt + 1}/{retries}): {e}')
+            logger.debug(f'HTTP error ({attempt + 1}/{retries}): {e}')
         except requests.exceptions.InvalidSchema as e:
-            logger.error(f'Invalid URL schema for "{url}": {e}')
+            logger.debug(f'Invalid URL schema for "{url}": {e}')
             break  # Don't retry on invalid schema
         except requests.exceptions.RequestException as e:
-            logger.error(f'Request failed ({attempt + 1}/{retries}): {e}')
+            logger.debug(f'Request failed ({attempt + 1}/{retries}): {e}')
 
         if attempt < retries - 1:
             logger.debug(f'Waiting {time_between_retries} seconds before retrying')
             time.sleep(time_between_retries)  # Wait before retrying
-    logger.debug(f'Failed to get a successful response for {url} after {retries} attempts')
+    logger.debug(f'Failed to get a successful response for "{url}" after {retries} attempts using common HTTP Request')
     return None
 
 
-def get_request_flaresolver(url: str,
-                            timeout: int = 20,
-                            flaresolver_url: str = FLARESOLVER_URL,
-                            retries: int = 3,
-                            time_between_retries: int = 1) -> requests.Response | None:
-    logger.debug(f'Starting get_request_flaresolver for {url} with timeout={timeout}, retries={retries}, time_between_retries={time_between_retries}')
+def _get_request_flaresolver(url: str,
+                             timeout: int,
+                             retries: int,
+                             time_between_retries: int,
+                             flaresolver_url: str) -> Optional[requests.Response]:
+    logger.debug(
+        f'Starting get_request_flaresolver for "{url}" with timeout={timeout}, '
+        f'retries={retries}, '
+        f'time_between_retries={time_between_retries}')
     for attempt in range(retries):
-        logger.debug(f'Attempt {attempt + 1} for {url} using FlareSolver')
+        logger.debug(f'Attempt {attempt + 1} for "{url}" using FlareSolver')
         try:
             response = requests.post(
                 flaresolver_url,
@@ -64,71 +72,76 @@ def get_request_flaresolver(url: str,
                 timeout=timeout
             )
             response.raise_for_status()
-            logger.debug(f'Successful response for {url} on attempt {attempt + 1} using FlareSolver')
+            logger.debug(f'Successful response for "{url}" on attempt {attempt + 1} using FlareSolver')
             return response
 
         except requests.exceptions.ConnectionError as e:
-            logger.error(f'Connection error ({attempt + 1}/{retries}), check FlareSolver host: {flaresolver_url}: {e}')
+            logger.warning(f'Connection error with flaresolver (URL: "{flaresolver_url}"): {e}')
+            logger.warning(f'If the url is incorrect, set the env variable "FLARESOLVER_URL" to the correct value')
+            logger.warning('If FlareSolver is not installed in your machine, consider installing it.')
+            break # Don't retry on Connection Error
         except requests.exceptions.Timeout as e:
-            logger.error(f'Request timed out ({attempt + 1}/{retries}): {e}')
+            logger.debug(f'Request timed out ({attempt + 1}/{retries}): {e}')
         except requests.exceptions.InvalidSchema as e:
-            logger.error(f'Invalid FlareSolver URL schema "{flaresolver_url}": {e}')
+            logger.debug(f'Invalid FlareSolver URL schema "{flaresolver_url}": {e}')
             break  # Don't retry on invalid schema
         except requests.exceptions.HTTPError as e:
-            logger.error(f'HTTP error ({attempt + 1}/{retries}): {e}')
+            logger.debug(f'HTTP error ({attempt + 1}/{retries}): {e}')
         except requests.exceptions.RequestException as e:
-            logger.error(f'Request failed ({attempt + 1}/{retries}): {e}')
+            logger.debug(f'Request failed ({attempt + 1}/{retries}): {e}')
         except json.JSONDecodeError as e:
-            logger.error(f'Invalid JSON response ({attempt + 1}/{retries}): {e}')
+            logger.debug(f'Invalid JSON response ({attempt + 1}/{retries}): {e}')
 
         if attempt < retries - 1:
             logger.debug(f'Waiting {time_between_retries} seconds before retrying')
             time.sleep(time_between_retries)  # Wait before retrying
-    logger.debug(f'Failed to get a successful response for {url} using FlareSolver after {retries} attempts')
+
+    logger.debug(f'Failed to get a successful response for "{url}" using FlareSolver after {retries} attempts')
     return None
 
 
 def get_html_content(url: str,
-                     retries: int = 5,
-                     flaresolver: bool = True,
+                     retries: int = 3,
+                     timeout: int = 20,
+                     time_between_retries: int = 3,
                      flaresolver_url: str = FLARESOLVER_URL,
-                     time_between_retries: int = 1,
-                     force_flaresolver: bool = FORCE_FLARESOLVER) -> str | None:
-    logger.debug(f'Starting get_html_content for {url} with retries={retries}, flaresolver={flaresolver}, flaresolver_url={flaresolver_url}, time_between_retries={time_between_retries}, force_flaresolver={force_flaresolver}')
+                     force_flaresolver: bool = FORCE_FLARESOLVER) -> Optional[str]:
+    logger.debug(
+        f'Requesting HTML Content for "{url}" with '
+        f'retries: "{retries}", '
+        f'timeout: "{timeout}", '
+        f'time between retries: "{time_between_retries}"')
+    if force_flaresolver:
+        logger.debug('Will directly try with FlareSolver')
+
     # First try with common HTTP request
     if not force_flaresolver:
-        response = get_request(
-            url, timeout=20, retries=retries, time_between_retries=time_between_retries)
-        if not response:
-            logger.warning(f'Failed to get response from {url} using common HTTP request')
-        elif not response.ok:
-            logger.warning(f'Response with errors from {url} using common HTTP request')
-        else:
-            logger.debug(f'Successfully retrieved HTML content from {url} using common HTTP request')
+        response = _get_request(url,
+                                timeout=timeout,
+                                retries=retries,
+                                time_between_retries=time_between_retries)
+        if response and response.ok:
+            logger.debug(f'Successfully retrieved HTML content from "{url}" using common HTTP request')
             return response.text
 
-    # If flaresolver is disabled, return None
-    if not flaresolver:
-        logger.debug(f'Flaresolver is disabled, returning None for {url}')
-        return None
-
     # Try with Flaresolver
-    logger.debug(f'Trying with Flaresolver for {url}')
-    response = get_request_flaresolver(
-        url, timeout=20, flaresolver_url=flaresolver_url, time_between_retries=time_between_retries)
-    if not response:
-        logger.critical(f'Failed to get response from {url} using FlareSolver')
-        return None
-    if not response.ok:
-        logger.critical(f'Response with errors from {url} using FlareSolver')
+    logger.debug(f'Trying with Flaresolver for "{url}"')
+    response = _get_request_flaresolver(url,
+                                timeout=timeout,
+                                retries=retries,
+                                time_between_retries=time_between_retries,
+                                flaresolver_url=flaresolver_url)
+    if not response or not response.ok:
+        logger.warning(f'Failed all attempts to get HTML content from "{url}')
         return None
 
     response_json = response.json()
     if 'solution' not in response_json:
-        logger.critical(f'No solution found in FlareSolver response for {url}')
+        logger.warning(f'No solution found in FlareSolver response for "{url}"')
         return None
     if 'response' not in response_json['solution']:
-        logger.critical(f'No response found in FlareSolver solution for {url}')
+        logger.warning(f'No response found in FlareSolver solution for "{url}"')
         return None
-    logger.debug(f'Successfully retrieved HTML content from {url} using FlareSolver')
+
+    logger.debug(f'Successfully retrieved HTML content from "{url}" using FlareSolver')
     return response_json['solution']['response']

web_novel_scraper/utils.py

@@ -1,10 +1,140 @@
-from .file_manager import FileManager
-from . import request_manager
+import json
+import shutil
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
 import hashlib
 from urllib.parse import urlparse
 import re
 import unicodedata
 
+class FileManagerError(Exception):
+    """Exception raised for any exception for file operations"""
+
+class FileOps:
+    """Static helper for disc operations."""
+
+    ## HELPERS
+
+    @staticmethod
+    def _atomic_tmp(path: Path) -> Path:
+        """Temporary file path in the same directory as *path*."""
+        return path.with_suffix(path.suffix + ".tmp")
+
+    ## DIRECTORY MANAGEMENT
+    @staticmethod
+    def ensure_dir(path: Path) -> Path:
+        """Create *path* (and parents) if missing."""
+        try:
+            path.mkdir(parents=True, exist_ok=True)
+            return path
+        except Exception as e:
+            raise FileManagerError(str(e)) from e
+
+    ## READ OPERATIONS
+
+    @staticmethod
+    def read_text(path: Path) -> Optional[str]:
+        """Return UTF-8 contents or None if *path* does not exist."""
+        if not path.exists():
+            return None
+        try:
+            return path.read_text(encoding="utf-8")
+        except Exception as e:
+            raise FileManagerError(str(e)) from e
+
+    @staticmethod
+    def read_json(path: Path | str) -> Optional[dict]:
+        """Return JSON object or None if *path* does not exist."""
+        path = Path(path)
+        raw = FileOps.read_text(path)
+        if raw is None:
+            return None
+        try:
+            return json.loads(raw)
+        except Exception as e:
+            raise FileManagerError(str(e)) from e
+
+    @staticmethod
+    def read_binary(path: Path) -> Optional[bytes]:
+        """Return binary contents or None if *path* does not exist."""
+        if not path.exists():
+            return None
+        try:
+            return path.read_bytes()
+        except Exception as e:
+            raise FileManagerError(str(e)) from e
+
+    ## WRITE OPERATION
+
+    @staticmethod
+    def save_text(path: Path, text: str) -> None:
+        """Atomically write UTF-8 text to *path*."""
+        tmp = FileOps._atomic_tmp(path)
+        try:
+            tmp.write_text(text, encoding="utf-8")
+            tmp.replace(path)
+        except Exception as e:
+            FileOps.delete(tmp)
+            raise FileManagerError(str(e)) from e
+
+    @staticmethod
+    def save_json(path: Path, obj: dict) -> None:
+        """Atomically write pretty-printed JSON to *path*."""
+        tmp = FileOps._atomic_tmp(path)
+        try:
+            tmp.write_text(json.dumps(obj, ensure_ascii=False, indent=2), encoding="utf-8")
+            tmp.replace(path)
+        except Exception as e:
+            FileOps.delete(tmp)
+            raise FileManagerError(str(e)) from e
+
+    @staticmethod
+    def save_binary(path: Path, data: bytes) -> None:
+        """Atomically write binary data to *path* (e.g., cover images)."""
+        tmp = FileOps._atomic_tmp(path)
+        try:
+            tmp.write_bytes(data)
+            tmp.replace(path)
+        except Exception as e:
+            FileOps.delete(tmp)
+            raise FileManagerError(str(e)) from e
+
+    ## DELETE/COPY OPERATIONS
+
+    @staticmethod
+    def delete(path: Path) -> None:
+        """Delete *path* if it exists."""
+        try:
+            if path.exists():
+                path.unlink()
+        except Exception as e:
+            raise FileManagerError(str(e)) from e
+
+    @staticmethod
+    def copy(src: Path, dst: Path) -> None:
+        """Copy *src* to *dst*."""
+        try:
+            shutil.copy(src, dst)
+        except Exception as e:
+            raise FileManagerError(str(e)) from e
+
+def _normalize_dirname(name: str) -> str:
+    """
+    Keep whitespace as-is while replacing any other unsupported characters
+    with an underscore.
+    Allowed: letters, digits, underscore, hyphen, and spaces.
+    """
+    # Collapse multiple spaces into a single space (optional; comment out if not desired)
+    name = re.sub(r'\s+', ' ', name.strip())
+
+    # Replace any char that is *not* letter, digit, underscore, hyphen, or space.
+    return re.sub(r'[^\w\-\s]', '_', name)
+
+def now_iso() -> str:
+    """Current timestamp in ISO-8601 (seconds precision)."""
+    return datetime.now(timezone.utc).astimezone().isoformat(timespec="seconds")
 
 def generate_file_name_from_url(url: str) -> str:
     # Parsea URL
@@ -64,3 +194,10 @@ def check_exclusive_params(param1: any, param2: any) -> bool:
 
 def create_volume_id(n: int):
     return f'v{n:02}'
+
+def check_incomplete_url(url: str) -> bool:
+    if url.startswith('?') or url.startswith('#'):
+        return True
+
+    parsed = urlparse(url)
+    return not parsed.scheme or not parsed.netloc

web_novel_scraper/version.py

@@ -1 +1 @@
-__version__ = "1.1.0"
+__version__ = "2.0.0"

{web_novel_scraper-1.1.0.dist-info → web_novel_scraper-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: web-novel-scraper
-Version: 1.1.0
+Version: 2.0.0
 Summary: Python tool that allows you to scrape web novels from various sources and save them to more readable formats like EPUB.
 Project-URL: Homepage, https://github.com/ImagineBrkr/web-novel-scraper
 Project-URL: Documentation, https://web-novel-scraper.readthedocs.io