novel-downloader 1.5.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

novel_downloader/utils/crypto_utils/rc4.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.utils.crypto_utils.rc4
+---------------------------------------
+
+Minimal RC4 stream cipher implementation.
+"""
+
+
+def rc4_init(key: bytes) -> list[int]:
+    """
+    Key-Scheduling Algorithm (KSA)
+    """
+    S = list(range(256))
+    j = 0
+    klen = len(key)
+    for i in range(256):
+        j = (j + S[i] + key[i % klen]) & 0xFF
+        S[i], S[j] = S[j], S[i]
+    return S
+
+
+def rc4_stream(S_init: list[int], data: bytes) -> bytes:
+    """
+    Pseudo-Random Generation Algorithm (PRGA)
+    """
+    # make a copy of S since it mutates during PRGA
+    S = S_init.copy()
+    i = 0
+    j = 0
+    out = bytearray(len(data))
+    for idx, ch in enumerate(data):
+        i = (i + 1) & 0xFF
+        j = (j + S[i]) & 0xFF
+        S[i], S[j] = S[j], S[i]
+        K = S[(S[i] + S[j]) & 0xFF]
+        out[idx] = ch ^ K
+
+    return bytes(out)
+
+
+def rc4_cipher(key: bytes, data: bytes) -> bytes:
+    """
+    RC4 stream cipher.
+
+    It performs the standard Key-Scheduling Algorithm (KSA) and
+    Pseudo-Random Generation Algorithm (PRGA) to produce the RC4 keystream.
+
+    :param key: RC4 key as bytes (must not be empty)
+    :param data: plaintext or ciphertext as bytes
+    :return: XORed bytes (encrypt/decrypt are identical)
+    """
+    S = rc4_init(key)
+    return rc4_stream(S, data)

novel_downloader/utils/epub/__init__.py

@@ -6,15 +6,14 @@ novel_downloader.utils.epub
 Top-level package for EPUB export utilities.
 
 Key components:
-
-- EpubBuilder : orchestrates metadata, manifest, spine, navigation, and resources
-- Chapter, Volume : represent and render content sections and volume intros
+  * EpubBuilder : orchestrates metadata, manifest, spine, navigation, and resources
+  * Chapter, Volume : represent and render content sections and volume intros
 
 Usage example:
 
 ```python
 builder = EpubBuilder(title="My Novel", author="Author Name", uid="uuid-1234")
-builder.add_chapter(Chapter(id="ch1", title="Chapter 1", content="<p>xxx</p>"))
+builder.chapters.append(Chapter(id="ch1", title="Chapter 1", content="<p>xxx</p>"))
 builder.export("output/my_novel.epub")
 ```
 """

novel_downloader/utils/epub/builder.py

@@ -4,14 +4,14 @@ novel_downloader.utils.epub.builder
 -----------------------------------
 
 Orchestrates the end-to-end EPUB build process by:
-- Managing metadata (title, author, description, language, etc.)
-- Collecting and deduplicating resources (chapters, images, stylesheets)
-- Registering everything in the OPF manifest and spine
-- Generating nav.xhtml, toc.ncx, content.opf, and the zipped .epub file
+  * Managing metadata (title, author, description, language, etc.)
+  * Collecting and deduplicating resources (chapters, images, stylesheets)
+  * Registering everything in the OPF manifest and spine
+  * Generating nav.xhtml, toc.ncx, content.opf, and the zipped .epub file
 
 Provides:
-- methods to add chapters, volumes, images, and styles
-- a clean `export()` entry point that writes the final EPUB archive
+  * methods to add chapters, volumes, images, and styles
+  * a clean `export()` entry point that writes the final EPUB archive
 """
 
 import zipfile

novel_downloader/utils/epub/constants.py

@@ -4,14 +4,13 @@ novel_downloader.utils.epub.constants
 -------------------------------------
 
 EPUB-specific constants used by the builder, including:
-- Directory names for OEBPS structure
-- XML namespace URIs
-- Package attributes and document-type declarations
-- Media type mappings for images
-- Template strings for container.xml and cover image HTML
+  * Directory names for OEBPS structure
+  * XML namespace URIs
+  * Package attributes and document-type declarations
+  * Media type mappings for images
+  * Template strings for container.xml and cover image HTML
 """
 
-PRETTY_PRINT_FLAG = True
 ROOT_PATH = "OEBPS"
 IMAGE_FOLDER = "Images"
 TEXT_FOLDER = "Text"
@@ -24,18 +23,6 @@ NCX_NS = "http://www.daisy.org/z3986/2005/ncx/"
 OPF_NS = "http://www.idpf.org/2007/opf"
 DC_NS = "http://purl.org/dc/elements/1.1/"
 
-OPF_PKG_ATTRIB = {
-    "version": "3.0",
-    "unique-identifier": "id",
-    "prefix": "rendition: http://www.idpf.org/vocab/rendition/#",
-}
-CHAP_DOC_TYPE = (
-    '<?xml version="1.0" encoding="utf-8"?>\n'
-    "<!DOCTYPE html PUBLIC "
-    '"-//W3C//DTD XHTML 1.1//EN" '
-    '"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
-)
-
 IMAGE_MEDIA_TYPES: dict[str, str] = {
     "png": "image/png",
     "jpg": "image/jpeg",
@@ -45,13 +32,15 @@ IMAGE_MEDIA_TYPES: dict[str, str] = {
     "webp": "image/webp",
 }
 
-CONTAINER_TEMPLATE = """<?xml version="1.0" encoding="UTF-8"?>
+CONTAINER_TEMPLATE = """\
+<?xml version="1.0" encoding="UTF-8"?>
 <container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
     <rootfiles>
         <rootfile full-path="{root_path}/content.opf"
             media-type="application/oebps-package+xml"/>
     </rootfiles>
-</container>"""
+</container>
+"""
 
 COVER_IMAGE_TEMPLATE = (
     f'<div style="text-align: center; margin: 0; padding: 0;">'
@@ -66,7 +55,8 @@ CSS_TMPLATE = (
 )
 
 CHAP_TMPLATE = f"""\
-{CHAP_DOC_TYPE}
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
 <html xmlns="{XHTML_NS}" xmlns:epub="{EPUB_NS}" lang="{{lang}}" xml:lang="{{lang}}">
   <head>
     <title>{{title}}</title>
@@ -75,3 +65,54 @@ CHAP_TMPLATE = f"""\
   <body>{{content}}</body>
 </html>
 """
+
+NAV_TEMPLATE = f"""\
+<?xml version='1.0' encoding='utf-8'?>
+<!DOCTYPE html>
+<html xmlns="{XHTML_NS}" xmlns:epub="{EPUB_NS}" lang="{{lang}}" xml:lang="{{lang}}">
+  <head>
+    <title>{{title}}</title>
+  </head>
+  <body>
+    <nav epub:type="toc" id="{{id}}" role="doc-toc">
+      <h2>{{title}}</h2>
+      <ol>
+{{items}}
+      </ol>
+    </nav>
+  </body>
+</html>
+"""
+
+NCX_TEMPLATE = f"""\
+<?xml version='1.0' encoding='utf-8'?>
+<ncx xmlns="{NCX_NS}" version="2005-1">
+  <head>
+    <meta name="dtb:uid" content="{{uid}}"/>
+    <meta name="dtb:depth" content="{{depth}}"/>
+    <meta name="dtb:totalPageCount" content="0"/>
+    <meta name="dtb:maxPageNumber" content="0"/>
+  </head>
+  <docTitle>
+    <text>{{title}}</text>
+  </docTitle>
+  <navMap>
+{{navpoints}}
+  </navMap>
+</ncx>
+"""
+
+OPF_TEMPLATE = f"""\
+<?xml version='1.0' encoding='utf-8'?>
+<package xmlns="{OPF_NS}" xmlns:dc="{DC_NS}" xmlns:opf="{OPF_NS}" version="3.0" unique-identifier="id" prefix="rendition: http://www.idpf.org/vocab/rendition/#">
+  <metadata>
+{{metadata}}
+  </metadata>
+  <manifest>
+{{manifest_items}}
+  </manifest>
+  <spine{{spine_toc}}>
+{{spine_items}}
+  </spine>
+{{guide_section}}</package>
+"""  # noqa: E501

novel_downloader/utils/epub/documents.py

@@ -4,27 +4,19 @@ novel_downloader.utils.epub.documents
 -------------------------------------
 
 Defines the classes that render EPUB navigation and packaging documents:
-- NavDocument: builds the XHTML nav.xhtml (EPUB 3)
-- NCXDocument: builds the NCX XML navigation map (EPUB 2)
-- OpfDocument: builds the content.opf package document
+  * NavDocument: builds the XHTML nav.xhtml (EPUB 3)
+  * NCXDocument: builds the NCX XML navigation map (EPUB 2)
+  * OpfDocument: builds the content.opf package document
 """
 
 from collections.abc import Sequence
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
 
-from lxml import etree
-from lxml.builder import ElementMaker
-
 from .constants import (
-    DC_NS,
-    EPUB_NS,
-    NCX_NS,
-    OPF_NS,
-    OPF_PKG_ATTRIB,
-    PRETTY_PRINT_FLAG,
-    XHTML_NS,
-    XML_NS,
+    NAV_TEMPLATE,
+    NCX_TEMPLATE,
+    OPF_TEMPLATE,
 )
 from .models import (
     ChapterEntry,
@@ -35,21 +27,6 @@ from .models import (
     VolumeEntry,
 )
 
-NAV = ElementMaker(
-    namespace=XHTML_NS,
-    nsmap={None: XHTML_NS, "epub": EPUB_NS},
-)
-NCX = ElementMaker(namespace=NCX_NS, nsmap={None: NCX_NS})
-PKG = ElementMaker(
-    namespace=OPF_NS,
-    nsmap={
-        None: OPF_NS,
-        "dc": DC_NS,
-        "opf": OPF_NS,
-    },
-)
-DC = ElementMaker(namespace=DC_NS)
-
 
 @dataclass
 class NavDocument(EpubResource):
@@ -60,12 +37,7 @@ class NavDocument(EpubResource):
     media_type: str = field(init=False, default="application/xhtml+xml")
     content_items: list[ChapterEntry | VolumeEntry] = field(default_factory=list)
 
-    def add_chapter(
-        self,
-        id: str,
-        label: str,
-        src: str,
-    ) -> None:
+    def add_chapter(self, id: str, label: str, src: str) -> None:
         """
         Add a top-level chapter entry to the navigation.
 
@@ -100,55 +72,29 @@ class NavDocument(EpubResource):
 
         :return: A string containing the full XHTML for nav.xhtml.
         """
-        # build the root <html> with both lang attributes
-        html_el = NAV.html(
-            # head/title
-            NAV.head(NAV.title(self.title)),
-            # body/nav/ol subtree
-            NAV.body(
-                NAV.nav(
-                    NAV.h2(self.title),
-                    NAV.ol(*self._render_items(self.content_items)),
-                    # namespaced + regular attributes
-                    **{
-                        f"{{{EPUB_NS}}}type": "toc",
-                        "id": self.id,
-                        "role": "doc-toc",
-                    },
-                )
-            ),
-            # html attributes
+        items_str = self._render_items_str(self.content_items)
+        raw = NAV_TEMPLATE.format(
             lang=self.language,
-            **{f"{{{XML_NS}}}lang": self.language},
+            id=self.id,
+            title=self.title,
+            items=items_str,
         )
-
-        xml_bytes = etree.tostring(
-            html_el,
-            xml_declaration=True,
-            encoding="utf-8",
-            pretty_print=PRETTY_PRINT_FLAG,
-            doctype="<!DOCTYPE html>",
-        )
-        xml_string: str = xml_bytes.decode("utf-8")
-        return xml_string
+        return raw
 
     @classmethod
-    def _render_items(
-        cls,
-        items: Sequence[ChapterEntry | VolumeEntry],
-    ) -> list[etree._Element]:
-        """
-        Recursively build <li> elements (and nested <ol>) for each TOC entry.
-        """
-        elements: list[etree._Element] = []
+    def _render_items_str(cls, items: Sequence[ChapterEntry | VolumeEntry]) -> str:
+        lines: list[str] = []
         for item in items:
             if isinstance(item, VolumeEntry) and item.chapters:
-                li = NAV.li(NAV.a(item.label, href=item.src))
-                li.append(NAV.ol(*cls._render_items(item.chapters)))
+                lines.append(f'<li><a href="{item.src}">{item.label}</a>')
+                lines.append("  <ol>")
+                child = cls._render_items_str(item.chapters)
+                lines.extend(child.splitlines())
+                lines.append("  </ol>")
+                lines.append("</li>")
             else:
-                li = NAV.li(NAV.a(item.label, href=item.src))
-            elements.append(li)
-        return elements
+                lines.append(f'<li><a href="{item.src}">{item.label}</a></li>')
+        return "\n".join(lines)
 
 
 @dataclass
@@ -190,29 +136,19 @@ class NCXDocument(EpubResource):
 
         :return: A string containing the full NCX XML document.
         """
-        root = NCX.ncx(version="2005-1")
-        head = NCX.head(
-            NCX.meta(name="dtb:uid", content=self.uid),
-            NCX.meta(name="dtb:depth", content=str(self._depth(self.nav_points))),
-            NCX.meta(name="dtb:totalPageCount", content="0"),
-            NCX.meta(name="dtb:maxPageNumber", content="0"),
+        order = 1
+        lines: list[str] = []
+        for pt in self.nav_points:
+            order, block = self._render_navpoint_str(pt, order)
+            lines.extend(block)
+        navpoints = "\n".join(lines)
+        raw = NCX_TEMPLATE.format(
+            uid=self.uid,
+            depth=self._depth(self.nav_points),
+            title=self.title,
+            navpoints=navpoints,
         )
-        root.append(head)
-        root.append(NCX.docTitle(NCX.text(self.title)))
-
-        navMap = NCX.navMap()
-        root.append(navMap)
-
-        self._render_navpoints(navMap, self.nav_points, start=1)
-
-        xml_bytes = etree.tostring(
-            root,
-            xml_declaration=True,
-            encoding="utf-8",
-            pretty_print=PRETTY_PRINT_FLAG,
-        )
-        xml_string: str = xml_bytes.decode("utf-8")
-        return xml_string
+        return raw
 
     @classmethod
     def _depth(cls, points: list[NavPoint]) -> int:
@@ -221,32 +157,21 @@ class NCXDocument(EpubResource):
         return 1 + max(cls._depth(child.children) for child in points)
 
     @classmethod
-    def _render_navpoints(
-        cls,
-        parent: etree._Element,
-        points: list[NavPoint],
-        start: int,
-    ) -> int:
-        """
-        Recursively append <navPoint> elements under `parent`,
-        assigning playOrder starting from `start`.
-        Returns the next unused playOrder.
-        """
-        play = start
-        for pt in points:
-            np = etree.SubElement(
-                parent,
-                "navPoint",
-                id=pt.id,
-                playOrder=str(play),
-            )
-            play += 1
-            navLabel = etree.SubElement(np, "navLabel")
-            lbl_text = etree.SubElement(navLabel, "text")
-            lbl_text.text = pt.label
-            etree.SubElement(np, "content", src=pt.src)
-            play = cls._render_navpoints(np, pt.children, play)
-        return play
+    def _render_navpoint_str(cls, pt: NavPoint, order: int) -> tuple[int, list[str]]:
+        lines: list[str] = []
+        # open navPoint
+        lines.append(f'<navPoint id="{pt.id}" playOrder="{order}">')
+        order += 1
+        # label and content
+        lines.append(f"<navLabel><text>{pt.label}</text></navLabel>")
+        lines.append(f'<content src="{pt.src}"/>')
+        # children
+        for child in pt.children:
+            order, child_lines = cls._render_navpoint_str(child, order)
+            lines.extend(child_lines)
+        # close
+        lines.append("</navPoint>")
+        return order, lines
 
 
 @dataclass
@@ -309,95 +234,64 @@ class OpfDocument(EpubResource):
         Generate the content.opf XML, which defines metadata, manifest, and spine.
 
         This function outputs a complete OPF package document that includes:
-        - <metadata>: title, author, language, identifiers, etc.
-        - <manifest>: all resource entries
-        - <spine>: the reading order of the content
-        - <guide>: optional references like cover page
+          * <metadata>: title, author, language, identifiers, etc.
+          * <manifest>: all resource entries
+          * <spine>: the reading order of the content
+          * <guide>: optional references like cover page
 
         :return: A string containing the full OPF XML content.
         """
         now_iso = datetime.now(UTC).replace(microsecond=0).isoformat()
 
-        # <package> root
-        package = PKG.package(**OPF_PKG_ATTRIB)
-
-        # <metadata>
-        metadata = PKG.metadata()
-        package.append(metadata)
-
-        # modified timestamp
-        modified = PKG.meta(property="dcterms:modified")
-        modified.text = now_iso
-        metadata.append(modified)
-
-        # mandatory DC elements
-        id_el = DC.identifier(id="id")
-        id_el.text = self.uid
-        title_el = DC.title()
-        title_el.text = self.title
-        lang_el = DC.language()
-        lang_el.text = self.language
-        metadata.extend([id_el, title_el, lang_el])
-
-        # optional DC elements
+        # metadata block
+        meta_lines: list[str] = []
+        meta_lines.append(f'<meta property="dcterms:modified">{now_iso}</meta>')
+        meta_lines.append(f'<dc:identifier id="id">{self.uid}</dc:identifier>')
+        meta_lines.append(f"<dc:title>{self.title}</dc:title>")
+        meta_lines.append(f"<dc:language>{self.language}</dc:language>")
         if self.author:
-            creator = DC.creator(id="creator")
-            creator.text = self.author
-            metadata.append(creator)
+            meta_lines.append(f'<dc:creator id="creator">{self.author}</dc:creator>')
         if self.description:
-            desc = DC.description()
-            desc.text = self.description
-            metadata.append(desc)
+            meta_lines.append(f"<dc:description>{self.description}</dc:description>")
         if self.subject:
-            subj = DC.subject()
-            subj.text = ",".join(self.subject)
-            metadata.append(subj)
+            joined = ",".join(self.subject)
+            meta_lines.append(f"<dc:subject>{joined}</dc:subject>")
         if self.include_cover and self._cover_item:
-            cover_meta = PKG.meta(name="cover", content=self._cover_item.id)
-            metadata.append(cover_meta)
+            meta_lines.append(f'<meta name="cover" content="{self._cover_item.id}"/>')
+        metadata = "\n".join(meta_lines)
 
-        # <manifest>
-        manifest_el = PKG.manifest()
+        # manifest block
+        man_lines: list[str] = []
         for item in self.manifest:
-            attrs = {
-                "id": item.id,
-                "href": item.href,
-                "media-type": item.media_type,
-            }
-            if item.properties:
-                attrs["properties"] = item.properties
-            manifest_el.append(PKG.item(**attrs))
-        package.append(manifest_el)
-
-        # <spine>
-        spine_attrs = {}
-        if self._toc_item:
-            spine_attrs["toc"] = self._toc_item.id
-        spine_el = PKG.spine(**spine_attrs)
+            props = f' properties="{item.properties}"' if item.properties else ""
+            man_lines.append(
+                f'<item id="{item.id}" href="{item.href}" media-type="{item.media_type}"{props}/>'  # noqa: E501
+            )
+        manifest_items = "\n".join(man_lines)
+
+        # spine block
+        toc_attr = f' toc="{self._toc_item.id}"' if self._toc_item else ""
+        spine_lines: list[str] = []
         for ref in self.spine:
-            attrs = {"idref": ref.idref}
-            if ref.properties:
-                attrs["properties"] = ref.properties
-            spine_el.append(PKG.itemref(**attrs))
-        package.append(spine_el)
+            props = f' properties="{ref.properties}"' if ref.properties else ""
+            spine_lines.append(f'    <itemref idref="{ref.idref}"{props}/>')
+        spine_items = "\n".join(spine_lines)
 
-        # optional <guide> for cover
+        # guide block
         if self.include_cover and self._cover_doc:
-            guide_el = PKG.guide()
-            guide_el.append(
-                PKG.reference(
-                    type="cover",
-                    title="Cover",
-                    href=self._cover_doc.href,
-                )
+            guide_section = (
+                "  <guide>\n"
+                f'    <reference type="cover" title="Cover" href="{self._cover_doc.href}"/>\n'  # noqa: E501
+                "  </guide>\n"
             )
-            package.append(guide_el)
-
-        xml_bytes = etree.tostring(
-            package,
-            xml_declaration=True,
-            encoding="utf-8",
-            pretty_print=PRETTY_PRINT_FLAG,
+        else:
+            guide_section = ""
+
+        raw = OPF_TEMPLATE.format(
+            metadata=metadata,
+            manifest_items=manifest_items,
+            spine_toc=toc_attr,
+            spine_items=spine_items,
+            guide_section=guide_section,
         )
-        xml_string: str = xml_bytes.decode("utf-8")
-        return xml_string
+        return raw

novel_downloader/utils/epub/models.py

@@ -4,14 +4,14 @@ novel_downloader.utils.epub.models
 ----------------------------------
 
 Defines the core EPUB data models and resource classes used by the builder:
-- Typed entries for table of contents (ChapterEntry, VolumeEntry)
-- Manifest and spine record types (ManifestEntry, SpineEntry)
-- Hierarchical NavPoint for NCX navigation
-- Base resource class (EpubResource) and specializations:
-    - StyleSheet
-    - ImageResource
-    - Chapter (with XHTML serialization)
-- Volume container for grouping chapters with optional intro and cover
+  * Typed entries for table of contents (ChapterEntry, VolumeEntry)
+  * Manifest and spine record types (ManifestEntry, SpineEntry)
+  * Hierarchical NavPoint for NCX navigation
+  * Base resource class (EpubResource) and specializations:
+    * StyleSheet
+    * ImageResource
+    * Chapter (with XHTML serialization)
+  * Volume container for grouping chapters with optional intro and cover
 """
 
 from __future__ import annotations
@@ -65,12 +65,6 @@ class NavPoint:
     src: str
     children: list[NavPoint] = field(default_factory=list)
 
-    def add_child(self, point: NavPoint) -> None:
-        """
-        Append a child nav point under this one.
-        """
-        self.children.append(point)
-
 
 @dataclass
 class EpubResource:
@@ -101,10 +95,6 @@ class Chapter(EpubResource):
     css: list[StyleSheet] = field(default_factory=list)
     media_type: str = field(init=False, default="application/xhtml+xml")
 
-    def __post_init__(self) -> None:
-        if not self.filename:
-            object.__setattr__(self, "filename", f"{self.id}.xhtml")
-
     def to_xhtml(self, lang: str = "zh-CN") -> str:
         """
         Generate the XHTML for a chapter.
@@ -128,7 +118,3 @@ class Volume:
     intro: str = ""
     cover: Path | None = None
     chapters: list[Chapter] = field(default_factory=list)
-
-    def add_chapter(self, chapter: Chapter) -> None:
-        """Append a chapter to this volume."""
-        self.chapters.append(chapter)