txt2ebook 0.1.157__py3-none-any.whl → 0.1.159__py3-none-any.whl

txt2ebook/formats/base.py

@@ -134,6 +134,113 @@ class BaseWriter(ABC):
             file.parent, self.config.output_folder, lower_underscore(file.stem)
         ).with_suffix(extension)
 
+    def _get_toc_content_for_split(self) -> str:
+        raise NotImplementedError
+
+    def _get_volume_chapter_content_for_split(
+        self, volume: Volume, chapter: Chapter
+    ) -> str:
+        raise NotImplementedError
+
+    def _get_chapter_content_for_split(self, chapter: Chapter) -> str:
+        raise NotImplementedError
+
+    def _get_file_extension_for_split(self) -> str:
+        raise NotImplementedError
+
+    def _export_multiple_files(self) -> None:
+        logger.info("Split multiple files")
+
+        extension = self._get_file_extension_for_split()
+        txt_filename = Path(self.config.input_file.name)
+
+        export_filename = self._get_metadata_filename_for_split(
+            txt_filename, extension
+        )
+        export_filename.parent.mkdir(parents=True, exist_ok=True)
+        logger.info("Creating %s", export_filename)
+        with open(export_filename, "w", encoding="utf8") as file:
+            file.write(self._to_metadata_txt())
+
+        sc_seq = 1
+        if self.config.with_toc:
+            export_filename = self._get_toc_filename_for_split(
+                txt_filename, extension
+            )
+            export_filename.parent.mkdir(parents=True, exist_ok=True)
+            logger.info("Creating %s", export_filename)
+            with open(export_filename, "w", encoding="utf8") as file:
+                file.write(self._get_toc_content_for_split())
+
+            sc_seq = 2
+
+        for section in self.book.toc:
+            section_seq = str(sc_seq).rjust(2, "0")
+
+            ct_seq = 0
+            if isinstance(section, Volume):
+                for chapter in section.chapters:
+                    chapter_seq = str(ct_seq).rjust(2, "0")
+                    export_filename = (
+                        self._get_volume_chapter_filename_for_split(
+                            txt_filename,
+                            section_seq,
+                            chapter_seq,
+                            section,
+                            chapter,
+                            extension,
+                        )
+                    )
+                    export_filename.parent.mkdir(parents=True, exist_ok=True)
+                    logger.info("Creating %s", export_filename)
+                    with open(export_filename, "w", encoding="utf8") as file:
+                        file.write(
+                            self._get_volume_chapter_content_for_split(
+                                section, chapter
+                            )
+                        )
+                    ct_seq = ct_seq + 1
+            if isinstance(section, Chapter):
+                export_filename = self._get_chapter_filename_for_split(
+                    txt_filename, section_seq, section, extension
+                )
+                export_filename.parent.mkdir(parents=True, exist_ok=True)
+                logger.info("Creating %s", export_filename)
+                with open(export_filename, "w", encoding="utf8") as file:
+                    file.write(self._get_chapter_content_for_split(section))
+
+            sc_seq = sc_seq + 1
+
+    def _get_metadata_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        raise NotImplementedError
+
+    def _get_toc_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        raise NotImplementedError
+
+    def _get_volume_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter_seq: str,
+        volume: Volume,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        raise NotImplementedError
+
+    def _get_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        raise NotImplementedError
+
     def _to_metadata_txt(self) -> str:
         metadata = [
             self._("title:") + self.book.title,

txt2ebook/formats/gmi.py

@@ -34,99 +34,98 @@ class GmiWriter(BaseWriter):
         if self.config.split_volume_and_chapter:
             self._export_multiple_files()
         else:
-            self._new_file()
+            output_filename = self._output_filename(".gmi")
+            output_filename.parent.mkdir(parents=True, exist_ok=True)
 
-    def _export_multiple_files(self) -> None:
-        logger.info("Split multiple files")
+            with open(output_filename, "w", encoding="utf8") as file:
+                logger.info(
+                    "Generate Gemini file: %s", output_filename.resolve()
+                )
+                file.write(self._to_gmi())
+
+            if self.config.open:
+                self._open_file(output_filename)
+
+    def _get_toc_content_for_split(self) -> str:
+        return self._to_toc("*", "# ")
+
+    def _get_volume_chapter_content_for_split(
+        self, volume: Volume, chapter: Chapter
+    ) -> str:
+        return self._to_volume_chapter_txt(volume, chapter)
+
+    def _get_chapter_content_for_split(self, chapter: Chapter) -> str:
+        return self._to_chapter_txt(chapter)
 
-        txt_filename = Path(self.config.input_file.name)
-        export_filename = Path(
+    def _get_file_extension_for_split(self) -> str:
+        return ".gmi"
+
+    def _get_metadata_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        return Path(
             txt_filename.resolve().parent.joinpath(
                 self.config.output_folder,
                 lower_underscore(
-                    f"00_{txt_filename.stem}_" + self._("metadata") + ".gmi"
+                    f"00_{txt_filename.stem}_" + self._("metadata") + extension
                 ),
             )
         )
-        export_filename.parent.mkdir(parents=True, exist_ok=True)
-        logger.info("Creating %s", export_filename)
-        with open(export_filename, "w", encoding="utf8") as file:
-            file.write(self._to_metadata_txt())
-
-        sc_seq = 1
-        if self.config.with_toc:
-            export_filename = Path(
-                txt_filename.resolve().parent.joinpath(
-                    self.config.output_folder,
-                    lower_underscore(
-                        f"01_{txt_filename.stem}_" + self._("toc") + ".gmi"
-                    ),
-                )
-            )
-            export_filename.parent.mkdir(parents=True, exist_ok=True)
-            logger.info("Creating %s", export_filename)
-            with open(export_filename, "w", encoding="utf8") as file:
-                file.write(self._to_toc("*", "# "))
 
-            sc_seq = 2
-
-        for section in self.book.toc:
-            section_seq = str(sc_seq).rjust(2, "0")
-
-            ct_seq = 0
-            if isinstance(section, Volume):
-                for chapter in section.chapters:
-                    chapter_seq = str(ct_seq).rjust(2, "0")
-                    filename = lower_underscore(
-                        (
-                            f"{section_seq}"
-                            f"_{chapter_seq}"
-                            f"_{txt_filename.stem}"
-                            f"_{section.title}"
-                            f"_{chapter.title}"
-                            ".gmi"
-                        )
-                    )
+    def _get_toc_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        return Path(
+            txt_filename.resolve().parent.joinpath(
+                self.config.output_folder,
+                lower_underscore(
+                    f"01_{txt_filename.stem}_" + self._("toc") + extension
+                ),
+            )
+        )
 
-                    export_filename = Path(
-                        txt_filename.resolve().parent.joinpath(
-                            self.config.output_folder, filename
-                        )
+    def _get_volume_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter_seq: str,
+        volume: Volume,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        return Path(
+            txt_filename.resolve().parent.joinpath(
+                self.config.output_folder,
+                lower_underscore(
+                    (
+                        f"{section_seq}"
+                        f"_{chapter_seq}"
+                        f"_{txt_filename.stem}"
+                        f"_{volume.title}"
+                        f"_{chapter.title}"
+                        f"{extension}"
                     )
-                    export_filename.parent.mkdir(parents=True, exist_ok=True)
-                    logger.info("Creating %s", export_filename)
-                    with open(export_filename, "w", encoding="utf8") as file:
-                        file.write(
-                            self._to_volume_chapter_txt(section, chapter)
-                        )
-                    ct_seq = ct_seq + 1
-            if isinstance(section, Chapter):
-                filename = lower_underscore(
-                    (f"{section_seq}_{txt_filename.stem}_{section.title}.gmi")
-                )
+                ),
+            )
+        )
 
-                export_filename = Path(
-                    txt_filename.resolve().parent.joinpath(
-                        self.config.output_folder, filename
+    def _get_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        return Path(
+            txt_filename.resolve().parent.joinpath(
+                self.config.output_folder,
+                lower_underscore(
+                    (
+                        f"{section_seq}_{txt_filename.stem}_{chapter.title}{extension}"
                     )
-                )
-                export_filename.parent.mkdir(parents=True, exist_ok=True)
-                logger.info("Creating %s", export_filename)
-                with open(export_filename, "w", encoding="utf8") as file:
-                    file.write(self._to_chapter_txt(section))
-
-            sc_seq = sc_seq + 1
-
-    def _new_file(self) -> None:
-        new_filename = self._output_filename(".gmi")
-        new_filename.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(new_filename, "w", encoding="utf8") as file:
-            logger.info("Generate GemText file: %s", new_filename.resolve())
-            file.write(self._to_gmi())
-
-        if self.config.open:
-            self._open_file(new_filename)
+                ),
+            )
+        )
 
     def _to_gmi(self) -> str:
         toc = self._to_toc("*", "# ") if self.config.with_toc else ""

txt2ebook/formats/md.py

@@ -33,99 +33,98 @@ class MdWriter(BaseWriter):
         if self.config.split_volume_and_chapter:
             self._export_multiple_files()
         else:
-            self._new_file()
+            output_filename = self._output_filename(".md")
+            output_filename.parent.mkdir(parents=True, exist_ok=True)
 
-    def _export_multiple_files(self) -> None:
-        logger.info("Split multiple files")
+            with open(output_filename, "w", encoding="utf8") as file:
+                logger.info(
+                    "Generate Markdown file: %s", output_filename.resolve()
+                )
+                file.write(self._to_md())
+
+            if self.config.open:
+                self._open_file(output_filename)
+
+    def _get_toc_content_for_split(self) -> str:
+        return self._to_toc("-", "# ")
+
+    def _get_volume_chapter_content_for_split(
+        self, volume: Volume, chapter: Chapter
+    ) -> str:
+        return self._to_volume_chapter_txt(volume, chapter)
+
+    def _get_chapter_content_for_split(self, chapter: Chapter) -> str:
+        return self._to_chapter_txt(chapter)
 
-        txt_filename = Path(self.config.input_file.name)
-        export_filename = Path(
+    def _get_file_extension_for_split(self) -> str:
+        return ".md"
+
+    def _get_metadata_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        return Path(
             txt_filename.resolve().parent.joinpath(
                 self.config.output_folder,
                 lower_underscore(
-                    f"00_{txt_filename.stem}_" + self._("metadata") + ".md"
+                    f"00_{txt_filename.stem}_" + self._("metadata") + extension
                 ),
             )
         )
-        export_filename.parent.mkdir(parents=True, exist_ok=True)
-        logger.info("Creating %s", export_filename)
-        with open(export_filename, "w", encoding="utf8") as file:
-            file.write(self._to_metadata_txt())
-
-        sc_seq = 1
-        if self.config.with_toc:
-            export_filename = Path(
-                txt_filename.resolve().parent.joinpath(
-                    self.config.output_folder,
-                    lower_underscore(
-                        f"01_{txt_filename.stem}_" + self._("toc") + ".md"
-                    ),
-                )
-            )
-            export_filename.parent.mkdir(parents=True, exist_ok=True)
-            logger.info("Creating %s", export_filename)
-            with open(export_filename, "w", encoding="utf8") as file:
-                file.write(self._to_toc("-", "# "))
 
-            sc_seq = 2
-
-        for section in self.book.toc:
-            section_seq = str(sc_seq).rjust(2, "0")
-
-            ct_seq = 0
-            if isinstance(section, Volume):
-                for chapter in section.chapters:
-                    chapter_seq = str(ct_seq).rjust(2, "0")
-                    filename = lower_underscore(
-                        (
-                            f"{section_seq}"
-                            f"_{chapter_seq}"
-                            f"_{txt_filename.stem}"
-                            f"_{section.title}"
-                            f"_{chapter.title}"
-                            ".md"
-                        )
-                    )
+    def _get_toc_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        return Path(
+            txt_filename.resolve().parent.joinpath(
+                self.config.output_folder,
+                lower_underscore(
+                    f"01_{txt_filename.stem}_" + self._("toc") + extension
+                ),
+            )
+        )
 
-                    export_filename = Path(
-                        txt_filename.resolve().parent.joinpath(
-                            self.config.output_folder, filename
-                        )
+    def _get_volume_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter_seq: str,
+        volume: Volume,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        return Path(
+            txt_filename.resolve().parent.joinpath(
+                self.config.output_folder,
+                lower_underscore(
+                    (
+                        f"{section_seq}"
+                        f"_{chapter_seq}"
+                        f"_{txt_filename.stem}"
+                        f"_{volume.title}"
+                        f"_{chapter.title}"
+                        f"{extension}"
                     )
-                    export_filename.parent.mkdir(parents=True, exist_ok=True)
-                    logger.info("Creating %s", export_filename)
-                    with open(export_filename, "w", encoding="utf8") as file:
-                        file.write(
-                            self._to_volume_chapter_txt(section, chapter)
-                        )
-                    ct_seq = ct_seq + 1
-            if isinstance(section, Chapter):
-                filename = lower_underscore(
-                    (f"{section_seq}_{txt_filename.stem}_{section.title}.md")
-                )
+                ),
+            )
+        )
 
-                export_filename = Path(
-                    txt_filename.resolve().parent.joinpath(
-                        self.config.output_folder, filename
+    def _get_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        return Path(
+            txt_filename.resolve().parent.joinpath(
+                self.config.output_folder,
+                lower_underscore(
+                    (
+                        f"{section_seq}_{txt_filename.stem}_{chapter.title}{extension}"
                     )
-                )
-                export_filename.parent.mkdir(parents=True, exist_ok=True)
-                logger.info("Creating %s", export_filename)
-                with open(export_filename, "w", encoding="utf8") as file:
-                    file.write(self._to_chapter_txt(section))
-
-            sc_seq = sc_seq + 1
-
-    def _new_file(self) -> None:
-        new_filename = self._output_filename(".md")
-        new_filename.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(new_filename, "w", encoding="utf8") as file:
-            logger.info("Generate Markdown file: %s", new_filename.resolve())
-            file.write(self._to_md())
-
-        if self.config.open:
-            self._open_file(new_filename)
+                ),
+            )
+        )
 
     def _to_md(self) -> str:
         toc = self._to_toc("-", "# ") if self.config.with_toc else ""

txt2ebook/formats/txt.py

@@ -16,6 +16,7 @@
 """Convert and backup source text file into text as well."""
 
 import logging
+import shutil
 from datetime import datetime as dt
 from pathlib import Path
 
@@ -40,130 +41,149 @@ class TxtWriter(BaseWriter):
         elif self.config.split_volume_and_chapter:
             self._export_multiple_files()
         else:
-            if self.config.overwrite:
-                self._overwrite_file()
-            else:
-                self._new_file()
+            output_filename = self._output_filename(".txt")
+            output_filename.parent.mkdir(parents=True, exist_ok=True)
+
+            if self.config.overwrite and output_filename == Path(
+                self.config.input_file.name
+            ):
+                ymd_hms = dt.now().strftime("%Y%m%d_%H%M%S")
+                backup_filename = Path(
+                    Path(self.config.input_file.name)
+                    .resolve()
+                    .parent.joinpath(
+                        lower_underscore(
+                            Path(self.config.input_file.name).stem
+                            + "_"
+                            + ymd_hms
+                            + ".txt"
+                        )
+                    )
+                )
+                logger.info(
+                    "Backup source text file: %s", backup_filename.resolve()
+                )
+                shutil.copyfile(output_filename, backup_filename)
 
-    def _export_multiple_files(self) -> None:
-        logger.info("Split multiple files")
+            with open(output_filename, "w", encoding="utf8") as file:
+                logger.info("Generate TXT file: %s", output_filename.resolve())
+                file.write(self._to_txt())
 
-        txt_filename = Path(self.config.input_file.name)
-        export_filename = Path(
+            if self.config.open:
+                self._open_file(output_filename)
+
+    def _get_metadata_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        return Path(
             txt_filename.resolve().parent.joinpath(
                 self.config.output_folder,
-                lower_underscore(
-                    f"00_{txt_filename.stem}_" + self._("metadata") + ".txt"
+                f"00_{txt_filename.stem}_" + self._("metadata") + extension,
+            )
+        )
+
+    def _get_toc_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        return Path(
+            txt_filename.resolve().parent.joinpath(
+                self.config.output_folder,
+                f"01_{txt_filename.stem}_" + self._("toc") + extension,
+            )
+        )
+
+    def _get_volume_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter_seq: str,
+        volume: Volume,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        return Path(
+            txt_filename.resolve().parent.joinpath(
+                self.config.output_folder,
+                (
+                    f"{section_seq}"
+                    f"_{chapter_seq}"
+                    f"_{txt_filename.stem}"
+                    f"_{volume.title}"
+                    f"_{chapter.title}"
+                    f"{extension}"
                 ),
             )
         )
-        export_filename.parent.mkdir(parents=True, exist_ok=True)
-        logger.info("Creating %s", export_filename)
-        with open(export_filename, "w", encoding="utf8") as file:
-            file.write(self._to_metadata_txt())
 
-        sc_seq = 1
-        if self.config.with_toc:
-            export_filename = Path(
-                txt_filename.resolve().parent.joinpath(
-                    self.config.output_folder,
-                    lower_underscore(
-                        f"01_{txt_filename.stem}_" + self._("toc") + ".txt"
-                    ),
-                )
+    def _get_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        return Path(
+            txt_filename.resolve().parent.joinpath(
+                self.config.output_folder,
+                (
+                    f"{section_seq}_{txt_filename.stem}_{chapter.title}{extension}"
+                ),
             )
-            export_filename.parent.mkdir(parents=True, exist_ok=True)
-            logger.info("Creating %s", export_filename)
-            with open(export_filename, "w", encoding="utf8") as file:
-                file.write(self._to_toc("-"))
+        )
 
-            sc_seq = 2
+    def _export_multiple_files(self) -> None:
+        """Export multiple files based on volume and chapter."""
+        txt_filename = Path(self.config.input_file.name)
+        txt_filename.parent.joinpath(self.config.output_folder).mkdir(
+            parents=True, exist_ok=True
+        )
 
-        for section in self.book.toc:
-            section_seq = str(sc_seq).rjust(2, "0")
+        # 1. Write metadata file
+        metadata_filename = self._get_metadata_filename_for_split(
+            txt_filename, ".txt"
+        )
+        with open(metadata_filename, "w", encoding="utf8") as file:
+            logger.info("Creating %s", metadata_filename.resolve())
+            file.write(self._to_metadata_txt())
 
-            ct_seq = 0
+        # 2. Write volume/chapter files
+        section_seq = 0
+        chapter_seq = 0
+        for section in self.book.toc:
             if isinstance(section, Volume):
+                section_seq += 1
+                chapter_seq = 0
                 for chapter in section.chapters:
-                    chapter_seq = str(ct_seq).rjust(2, "0")
-                    filename = lower_underscore(
-                        (
-                            f"{section_seq}"
-                            f"_{chapter_seq}"
-                            f"_{txt_filename.stem}"
-                            f"_{section.title}"
-                            f"_{chapter.title}"
-                            ".txt"
-                        )
-                    )
-
-                    export_filename = Path(
-                        txt_filename.resolve().parent.joinpath(
-                            self.config.output_folder, filename
-                        )
+                    chapter_seq += 1
+                    output_filename = self._get_volume_chapter_filename_for_split(
+                        txt_filename,
+                        str(section_seq).rjust(2, "0"),
+                        str(chapter_seq).rjust(2, "0"),
+                        section,
+                        chapter,
+                        ".txt",
                     )
-                    export_filename.parent.mkdir(parents=True, exist_ok=True)
-                    logger.info("Creating %s", export_filename)
-                    with open(export_filename, "w", encoding="utf8") as file:
-                        file.write(
-                            self._to_volume_chapter_txt(section, chapter)
-                        )
-                    ct_seq = ct_seq + 1
-            if isinstance(section, Chapter):
-                filename = lower_underscore(
-                    (f"{section_seq}_{txt_filename.stem}_{section.title}.txt")
+                    with open(output_filename, "w", encoding="utf8") as file:
+                        logger.info("Creating %s", output_filename.resolve())
+                        file.write(self._to_volume_chapter_txt(section, chapter))
+            elif isinstance(section, Chapter):
+                section_seq += 1
+                output_filename = self._get_chapter_filename_for_split(
+                    txt_filename,
+                    str(section_seq).rjust(2, "0"),
+                    section,
+                    ".txt",
                 )
-
-                export_filename = Path(
-                    txt_filename.resolve().parent.joinpath(
-                        self.config.output_folder, filename
-                    )
-                )
-                export_filename.parent.mkdir(parents=True, exist_ok=True)
-                logger.info("Creating %s", export_filename)
-                with open(export_filename, "w", encoding="utf8") as file:
+                with open(output_filename, "w", encoding="utf8") as file:
+                    logger.info("Creating %s", output_filename.resolve())
                     file.write(self._to_chapter_txt(section))
 
-            sc_seq = sc_seq + 1
-
-    def _new_file(self) -> None:
-        new_filename = self._output_filename(".txt")
-        txt_filename = Path(self.config.input_file.name)
-
-        if new_filename == txt_filename:
-            ymd_hms = dt.now().strftime("%Y%m%d_%H%M%S")
-            new_filename = Path(
-                txt_filename.resolve().parent.joinpath(
-                    lower_underscore(
-                        txt_filename.stem + "_" + ymd_hms + ".txt"
-                    )
-                )
-            )
-
-        new_filename.parent.mkdir(parents=True, exist_ok=True)
-
-        with open(new_filename, "w", encoding="utf8") as file:
-            file.write(self._to_txt())
-            logger.info("Generate TXT file: %s", new_filename.resolve())
-
         if self.config.open:
-            self._open_file(new_filename)
-
-    def _overwrite_file(self) -> None:
-        txt_filename = Path(self.config.input_file.name)
-
-        with open(txt_filename, "w", encoding="utf8") as file:
-            file.write(self._to_txt())
-            logger.info("Overwrite txt file: %s", txt_filename.resolve())
-
-        if self.config.open:
-            self._open_file(txt_filename)
+            self._open_file(metadata_filename)
 
     def _to_txt(self) -> str:
         toc = self._to_toc("-") if self.config.with_toc else ""
         return self._to_metadata_txt() + toc + self._to_body_txt()
-
-    def _to_body_txt(self) -> str:
         content = []
         for section in self.book.toc:
             if isinstance(section, Volume):

txt2ebook/formats/typ.py

@@ -18,11 +18,13 @@
 import importlib.resources as importlib_res
 import logging
 import textwrap
+from pathlib import Path
 
 import importlib_resources
 import typst
 
 from txt2ebook.formats.base import BaseWriter
+from txt2ebook.helpers import lower_underscore
 from txt2ebook.models import Chapter, Volume
 
 # workaround for Python 3.8
@@ -43,9 +45,6 @@ class TypWriter(BaseWriter):
 
     def write(self) -> None:
         """Generate Typst files."""
-        self._new_file()
-
-    def _new_file(self) -> None:
         new_filename = self._output_filename(".typ")
         new_filename.parent.mkdir(parents=True, exist_ok=True)
 
@@ -210,6 +209,20 @@ class TypWriter(BaseWriter):
 
         return self.config.paragraph_separator.join(pars)
 
+    def _get_file_extension_for_split(self) -> str:
+        return ".typ"
+
+    def _get_toc_content_for_split(self) -> str:
+        return self._to_outline()
+
+    def _get_volume_chapter_content_for_split(
+        self, volume: Volume, chapter: Chapter
+    ) -> str:
+        return self._to_volume_chapter_txt(volume, chapter)
+
+    def _get_chapter_content_for_split(self, chapter: Chapter) -> str:
+        return self._to_chapter_txt(chapter)
+
     def _index_pages(self) -> str:
         return textwrap.dedent(
             """
@@ -221,3 +234,35 @@ class TypWriter(BaseWriter):
             ]
         """
         )
+
+    def _get_metadata_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        return Path(self._output_folder(), "metadata").with_suffix(extension)
+
+    def _get_toc_filename_for_split(
+        self, txt_filename: Path, extension: str
+    ) -> Path:
+        return Path(self._output_folder(), "toc").with_suffix(extension)
+
+    def _get_volume_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter_seq: str,
+        volume: Volume,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        filename = f"{section_seq}-{lower_underscore(volume.title)}-{chapter_seq}-{lower_underscore(chapter.title)}"
+        return Path(self._output_folder(), filename).with_suffix(extension)
+
+    def _get_chapter_filename_for_split(
+        self,
+        txt_filename: Path,
+        section_seq: str,
+        chapter: Chapter,
+        extension: str,
+    ) -> Path:
+        filename = f"{section_seq}-{lower_underscore(chapter.title)}"
+        return Path(self._output_folder(), filename).with_suffix(extension)

txt2ebook/subcommands/epub.py

@@ -38,10 +38,10 @@ def build_subparser(subparsers) -> None:
 
     epub_parser.add_argument(
         "input_file",
-        nargs="*",
+        nargs=1,
         type=argparse.FileType("rb"),
-        help="source text filenames (can use glob patterns)",
-        metavar="TXT_FILENAMES",
+        help="source text filename",
+        metavar="TXT_FILENAME",
     )
 
     epub_parser.add_argument(
@@ -125,12 +125,12 @@ def run(args: argparse.Namespace) -> None:
     """
     input_sources = []
 
-    if not sys.stdin.isatty():
-        # piped input, use stdin as the single input source
-        input_sources.append(sys.stdin)
-    elif args.input_file:
-        # multiple file(s)
+    if args.input_file:
+        # File path(s) were explicitly provided on the command line
         input_sources.extend(args.input_file)
+    elif not sys.stdin.isatty():
+        # No file path provided, check for piped input
+        input_sources.append(sys.stdin)
     else:
         logger.error("No input files provided.")
         sys.exit(1)
@@ -147,6 +147,10 @@ def run(args: argparse.Namespace) -> None:
         current_file_args = argparse.Namespace(**vars(args))
         current_file_args.input_file = current_input_stream
 
+        logger.debug(
+            "Create separate volume page: %s", current_file_args.volume_page
+        )
+
         # if an explicit output_file was provided, it must apply to the first
         # input
         if i > 0 and args.output_file:

txt2ebook/subcommands/massage.py

@@ -28,7 +28,9 @@ from bs4 import UnicodeDammit
 
 from txt2ebook import detect_and_expect_language
 from txt2ebook.exceptions import EmptyFileError
+from txt2ebook.formats.txt import TxtWriter
 from txt2ebook.models.book import Book
+from txt2ebook.parser import Parser
 from txt2ebook.zh_utils import zh_halfwidth_to_fullwidth, zh_words_to_numbers
 
 logger = logging.getLogger(__name__)
@@ -216,26 +218,27 @@ def run(args: argparse.Namespace) -> None:
         None
     """
     massaged_txt = massage_txt(args)
-    if args.overwrite:
-        _overwrite_file(args, massaged_txt)
-    else:
-        _new_file(args, massaged_txt)
 
-    # args.language = detect_and_expect_language(massaged_txt, args.language)
-    # config_lang = args.language.replace("-", "_")
-    # langconf = import_module(f"txt2ebook.languages.{config_lang}")
-    # args.with_toc = False
-    # parser = Parser(massaged_txt, args, langconf)
-    # book = parser.parse()
+    if args.split_volume_and_chapter:
+        args.language = detect_and_expect_language(massaged_txt, args.language)
+        config_lang = args.language.replace("-", "_")
+        langconf = import_module(f"txt2ebook.languages.{config_lang}")
+        args.with_toc = False
+        parser = Parser(massaged_txt, args, langconf)
+        book = parser.parse()
 
-    # if args.debug:
-    #     book.debug(args.verbose)
+        if args.debug:
+            book.debug(args.verbose)
 
-    # if args.header_number:
-    #     book = header_number(args, book)
+        if args.header_number:
+            book = header_number(args, book)
 
-    # writer = TxtWriter(book, args)
-    # writer.write()
+        writer = TxtWriter(book, args)
+        writer.write()
+    elif args.overwrite:
+        _overwrite_file(args, massaged_txt)
+    else:
+        _new_file(args, massaged_txt)
 
 
 def _overwrite_file(args, massaged_txt) -> None:
@@ -356,11 +359,13 @@ def massage_txt(args: argparse.Namespace) -> str:
     if args.re_delete_line:
         body = do_delete_line_regex(args, body)
 
-    if args.single_newline:
-        body = do_single_newline(args, body)
-
     if args.width:
         body = do_wrapping(args, body)
+    elif args.single_newline:
+        body = do_single_newline(args, body)
+    else:
+        # Apply paragraph separation and line unwrapping by default
+        body = _unwrap_content(args, body)
 
     return f"{metadata}{body}"
 
@@ -376,6 +381,7 @@ def to_unix_newline(content: str) -> str:
     """
     return content.replace("\r\n", "\n").replace("\r", "\n")
 
+
 def do_reindent_paragraph(args, content: str) -> str:
     """Reindent each paragraph.
 
@@ -385,16 +391,16 @@ def do_reindent_paragraph(args, content: str) -> str:
     Returns:
         str: The formatted book content.
     """
-    paragraphs = re.split(r'\n\s*\n+', content)
+    paragraphs = re.split(r"\n\s*\n+", content)
     reindented_paragraphs = []
     for paragraph in paragraphs:
-        lines = paragraph.split('\n')
+        lines = paragraph.split("\n")
         reindented_lines = []
         for line in lines:
             stripped_line = line.strip()
             reindented_lines.append(stripped_line)
 
-        reindented_paragraph = '\n'.join(reindented_lines)
+        reindented_paragraph = "\n".join(reindented_lines)
         reindented_paragraph = "　　" + reindented_paragraph
         reindented_paragraphs.append(reindented_paragraph)
 
@@ -542,7 +548,7 @@ def _unwrap_content(args: argparse.Namespace, content: str) -> str:
     Returns:
         str: The formatted book content.
     """
-    paragraphs = content.split(args.paragraph_separator)
+    paragraphs = re.split(r"\n\s*\n+", content)
     processed_paragraphs = []
     for paragraph in paragraphs:
         single_line_paragraph = " ".join(paragraph.splitlines())

{txt2ebook-0.1.157.dist-info → txt2ebook-0.1.159.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: txt2ebook
-Version: 0.1.157
+Version: 0.1.159
 Summary: CLI tool to convert txt file to ebook format
 Author-email: Kian-Meng Ang <kianmeng@cpan.org>
 License-Expression: AGPL-3.0-or-later

{txt2ebook-0.1.157.dist-info → txt2ebook-0.1.159.dist-info}/RECORD

@@ -6,14 +6,14 @@ txt2ebook/parser.py,sha256=ITn6pGHO4vTfdrYouVV2mEe9jUM2zm3-FKEcspp2qzI,8968
 txt2ebook/tokenizer.py,sha256=UGyOBGxlKOXJtvP2UFp38EgFym8-PAU3A7Jl9RF3w6Y,10299
 txt2ebook/zh_utils.py,sha256=0Yq9r-JL4HntW68vFR6TBP9yQim1a07mfsh_sp-XmaE,4887
 txt2ebook/formats/__init__.py,sha256=_fW9UuoOTFxCKlej6t-PsFzJOqDFLzVatCci9tcPQeE,1645
-txt2ebook/formats/base.py,sha256=xUrLOPlJyV_8tSIbBzrbBe3fP481CuHYSdOUSdtxeik,5796
+txt2ebook/formats/base.py,sha256=bPpfKZwz3KeEtNRYJPZJJIKRcANGs_tw5a3uOw1pzSs,9625
 txt2ebook/formats/epub.py,sha256=IVz-FmYQlcChOw38YqfKy46bPVSIrHyxA_94iz06N3Y,6941
-txt2ebook/formats/gmi.py,sha256=k9PY6tcXf1aXrW3ZGo-0nvt1PDS1LoG5i31hze5oYqM,6662
-txt2ebook/formats/md.py,sha256=BzT3jsSYZR7rx9Lxuu1DvxCWQutSmMzoab8huKvxaxE,6408
+txt2ebook/formats/gmi.py,sha256=tUCEHtRHDupEPJ8dYPpxpE6yEKHCk8PRXR0zgjJFgsI,5837
+txt2ebook/formats/md.py,sha256=ZleBFNOGRhWr5WgcA8uyLXBxJm1bdQaunqzjocQYSkI,5587
 txt2ebook/formats/pdf.py,sha256=tr_ozVlL976yo7Ggny71zjOwzSd6tSnHTl7mcsLII_g,7263
 txt2ebook/formats/tex.py,sha256=V5B1nPR-WzGc4jqWu-BqxfQhtQsUTKM_sZZJsCcDBAk,5897
-txt2ebook/formats/txt.py,sha256=0DOVBTDRV2gcixham5Wj7NaZlNKAeLG9MLRlZgtUxqM,7412
-txt2ebook/formats/typ.py,sha256=MNclD5RdCnYAmPRzAaI6ZE6NnI8GdHKJla54wyfTUdc,6705
+txt2ebook/formats/txt.py,sha256=1f-e53oPyhyElLLKqZZ4_HJxIJkwyVjZLi0pnl02EM8,7929
+txt2ebook/formats/typ.py,sha256=0WjGeZHxbdCV1grYkEpgUocehWfmeJz8Ur9cT2ADlFI,8269
 txt2ebook/formats/templates/__init__.py,sha256=f3K7pJByNmmvu-wvziks6qb2QnnLmkDjUACXyw2s60E,760
 txt2ebook/formats/templates/epub/__init__.py,sha256=-XVLvnknTJTmQZY9UTH705vMcHgy56rQVRTusYawEZ4,766
 txt2ebook/helpers/__init__.py,sha256=c2EItHvPABDORfgfjArfa5XR--43es4D1tKWqaPcBxY,1309
@@ -27,17 +27,17 @@ txt2ebook/models/chapter.py,sha256=6YvUDHzR6amGMZgkQl_xHWrYZUmlfpF7mnDLilG2BpA,1
 txt2ebook/models/volume.py,sha256=koz1KfWjvGWLFbmGEQlZ23frsP93cDsuBMySYBHiXm8,1597
 txt2ebook/subcommands/__init__.py,sha256=ldhzvsrMsR8lZmhZef77JFz0jValpV3pytFfwJSkjls,1146
 txt2ebook/subcommands/env.py,sha256=gEzra4b6guy7pRZUTCWX1_eiR7JmrtR1Z-J-vxljvMY,1549
-txt2ebook/subcommands/epub.py,sha256=oVk00rypqN53UAOIYhOofkAPbjrdlvkszLDIdVqexvE,4706
+txt2ebook/subcommands/epub.py,sha256=xaXKATCioRVr-vN_Lw4SqQxJdm6dSWs-y3RyTpV3ZV8,4824
 txt2ebook/subcommands/gmi.py,sha256=ANnPg-RFsylTo44fUzFOSHN1fC3Ce82gBzrv-sBv5fU,3318
-txt2ebook/subcommands/massage.py,sha256=WmHHJQLowdjSDQnEqxVKsU9YsabY7fw4mBkfddsFZpI,15535
+txt2ebook/subcommands/massage.py,sha256=f_moVt19n60QH2T2J_EwZnCv1JNFrqLGu5j2VZfp_Lk,15793
 txt2ebook/subcommands/md.py,sha256=PmIqrqrnzLywvN4qTkle0V9N3FTIJGRWpC0Xbk76B5o,3329
 txt2ebook/subcommands/parse.py,sha256=xjhW8I9zS5DL3n3m04RyFofgci-6-_L6aF3d4N7c7M4,2938
 txt2ebook/subcommands/pdf.py,sha256=1JQtpugzAIaho6G3CK1rGYk74hotAexXZxPH9PHpRps,2980
 txt2ebook/subcommands/tex.py,sha256=8XqTV5GsOEr7sGSLUJB-B1KefIMxW3_BDq_Jm96Bt1Y,4369
 txt2ebook/subcommands/typ.py,sha256=xeJ_cPmyq_uouUBiH2kbcscckHLqewPmu9j0WO36sXY,4814
-txt2ebook-0.1.157.dist-info/licenses/LICENSE.md,sha256=tGtFDwxWTjuR9syrJoSv1Hiffd2u8Tu8cYClfrXS_YU,31956
-txt2ebook-0.1.157.dist-info/METADATA,sha256=WSRHi5sIRSNXPlUpUSYK7GWueOhHAdczDQfC3XSUHX4,5295
-txt2ebook-0.1.157.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-txt2ebook-0.1.157.dist-info/entry_points.txt,sha256=3jm5vpUsDRgoM6S3CQVMMiP7tJQqfq1vfV0sh_KaK9s,74
-txt2ebook-0.1.157.dist-info/top_level.txt,sha256=pesdk4CJRlfhUXVD9vH3Dd_F8ATlLQoqlUsUnU8SJMw,10
-txt2ebook-0.1.157.dist-info/RECORD,,
+txt2ebook-0.1.159.dist-info/licenses/LICENSE.md,sha256=tGtFDwxWTjuR9syrJoSv1Hiffd2u8Tu8cYClfrXS_YU,31956
+txt2ebook-0.1.159.dist-info/METADATA,sha256=SaESbcwNBN1WQMIbsaHoUWuEnjYxNQoZqZgg5CeYZag,5295
+txt2ebook-0.1.159.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+txt2ebook-0.1.159.dist-info/entry_points.txt,sha256=3jm5vpUsDRgoM6S3CQVMMiP7tJQqfq1vfV0sh_KaK9s,74
+txt2ebook-0.1.159.dist-info/top_level.txt,sha256=pesdk4CJRlfhUXVD9vH3Dd_F8ATlLQoqlUsUnU8SJMw,10
+txt2ebook-0.1.159.dist-info/RECORD,,