txt2ebook 0.1.156__tar.gz → 0.1.158__tar.gz

{txt2ebook-0.1.156/src/txt2ebook.egg-info → txt2ebook-0.1.158}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: txt2ebook
-Version: 0.1.156
+Version: 0.1.158
 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
@@ -39,6 +39,22 @@ Requires-Dist: regex<2022,>=2021.11.10
 Requires-Dist: reportlab<5,>=4.0.0
 Requires-Dist: typing-extensions<5,>=4.5.0
 Requires-Dist: typst>=0.13.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-randomly; extra == "test"
+Requires-Dist: pytest-xdist; extra == "test"
+Requires-Dist: scripttest; extra == "test"
+Provides-Extra: doc
+Requires-Dist: myst-parser; extra == "doc"
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: sphinx-autobuild; extra == "doc"
+Requires-Dist: sphinx-autodoc-typehints; extra == "doc"
+Requires-Dist: sphinx-copybutton; extra == "doc"
+Provides-Extra: lint
+Requires-Dist: pre-commit; extra == "lint"
+Requires-Dist: ruff; extra == "lint"
+Requires-Dist: mypy; extra == "lint"
 Dynamic: license-file
 
 # txt2ebook

{txt2ebook-0.1.156 → txt2ebook-0.1.158}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "txt2ebook"
-version = "0.1.156"
+version = "0.1.158"
 description = "CLI tool to convert txt file to ebook format"
 authors = [{ name = "Kian-Meng Ang", email = "kianmeng@cpan.org" }]
 requires-python = "~=3.9"
@@ -60,26 +60,26 @@ Repository = "https://github.com/kianmeng/txt2ebook"
 txt2ebook = "txt2ebook.cli:main"
 tte = "txt2ebook.cli:main"
 
-[dependency-groups]
-dev = [
-    "babel",
-    "bandit",
-    "flake8-simplify",
-    "mypy",
-    "myst-parser",
-    "nox",
-    "pep8-naming",
-    "pre-commit",
+[project.optional-dependencies]
+test = [
+    "pytest",
     "pytest-cov",
     "pytest-randomly",
     "pytest-xdist",
-    "pytest",
-    "ruff",
     "scripttest",
+]
+doc = [
+    "myst-parser",
+    "sphinx",
+    "sphinx-autobuild",
     "sphinx-autodoc-typehints",
     "sphinx-copybutton",
-    "sphinx",
-    "vulture",
+]
+
+lint = [
+    "pre-commit",
+    "ruff",
+    "mypy",
 ]
 
 [build-system]

{txt2ebook-0.1.156 → txt2ebook-0.1.158}/src/txt2ebook/formats/base.py

@@ -24,6 +24,7 @@ import shutil
 import subprocess
 import sys
 from abc import ABC, abstractmethod
+from datetime import datetime as dt
 from importlib import import_module
 from pathlib import Path
 
@@ -134,6 +135,98 @@ 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
+
+    @abstractmethod
+    def _get_metadata_filename_for_split(self, txt_filename: Path, extension: str) -> Path:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _get_toc_filename_for_split(self, txt_filename: Path, extension: str) -> Path:
+        raise NotImplementedError
+
+    @abstractmethod
+    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
+
+    @abstractmethod
+    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-0.1.158/src/txt2ebook/formats/gmi.py

@@ -0,0 +1,164 @@
+# Copyright (c) 2021,2022,2023,2024,2025 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Convert and back source text file into text as well."""
+
+import logging
+from pathlib import Path
+from typing import List
+
+from txt2ebook.formats.base import BaseWriter
+from txt2ebook.helpers import lower_underscore
+from txt2ebook.models import Chapter, Volume
+
+logger = logging.getLogger(__name__)
+
+
+class GmiWriter(BaseWriter):
+    """Module for writing ebook in GemText (gmi) format."""
+
+    def write(self) -> None:
+        """Generate GemText files."""
+        if self.config.split_volume_and_chapter:
+            self._export_multiple_files()
+        else:
+            output_filename = self._output_filename(".gmi")
+            output_filename.parent.mkdir(parents=True, exist_ok=True)
+
+            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)
+
+    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") + 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,
+                lower_underscore(
+                    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,
+                lower_underscore(
+                    (
+                        f"{section_seq}"
+                        f"_{chapter_seq}"
+                        f"_{txt_filename.stem}"
+                        f"_{volume.title}"
+                        f"_{chapter.title}"
+                        f"{extension}"
+                    )
+                ),
+            )
+        )
+
+    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}")
+                ),
+            )
+        )
+
+    def _to_gmi(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):
+                content.append(self._to_volume_txt(section))
+            if isinstance(section, Chapter):
+                content.append(self._to_chapter_txt(section))
+
+        return f"{self.config.paragraph_separator}".join(content)
+
+    def _to_volume_txt(self, volume) -> str:
+        return (
+            f"# {volume.title}"
+            + self.config.paragraph_separator
+            + self.config.paragraph_separator.join(
+                [
+                    self._to_chapter_txt(chapter, True)
+                    for chapter in volume.chapters
+                ]
+            )
+        )
+
+    def _to_chapter_txt(self, chapter, part_of_volume=False) -> str:
+        header = "##" if part_of_volume else "#"
+        return (
+            f"{header} {chapter.title}"
+            + self.config.paragraph_separator
+            + self.config.paragraph_separator.join(
+                self._remove_newline(chapter.paragraphs)
+            )
+        )
+
+    def _to_volume_chapter_txt(self, volume, chapter) -> str:
+        return (
+            f"# {volume.title} {chapter.title}"
+            + self.config.paragraph_separator
+            + self.config.paragraph_separator.join(
+                self._remove_newline(chapter.paragraphs)
+            )
+        )
+
+    def _remove_newline(self, paragraphs) -> List:
+        return list(map(lambda p: p.replace("\n", ""), paragraphs))

txt2ebook-0.1.158/src/txt2ebook/formats/md.py

@@ -0,0 +1,157 @@
+# Copyright (c) 2021,2022,2023,2024,2025 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Convert and back source text file into text as well."""
+
+import logging
+from pathlib import Path
+from pathlib import Path
+
+from txt2ebook.formats.base import BaseWriter
+from txt2ebook.helpers import lower_underscore
+from txt2ebook.models import Chapter, Volume
+
+logger = logging.getLogger(__name__)
+
+
+class MdWriter(BaseWriter):
+    """Module for writing ebook in Markdown (md) format."""
+
+    def write(self) -> None:
+        """Generate Markdown files."""
+        if self.config.split_volume_and_chapter:
+            self._export_multiple_files()
+        else:
+            output_filename = self._output_filename(".md")
+            output_filename.parent.mkdir(parents=True, exist_ok=True)
+
+            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)
+
+    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") + 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,
+                lower_underscore(
+                    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,
+                lower_underscore(
+                    (
+                        f"{section_seq}"
+                        f"_{chapter_seq}"
+                        f"_{txt_filename.stem}"
+                        f"_{volume.title}"
+                        f"_{chapter.title}"
+                        f"{extension}"
+                    )
+                ),
+            )
+        )
+
+    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}")
+                ),
+            )
+        )
+
+    def _to_md(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):
+                content.append(self._to_volume_txt(section))
+            if isinstance(section, Chapter):
+                content.append(self._to_chapter_txt(section))
+
+        return f"{self.config.paragraph_separator}".join(content)
+
+    def _to_volume_txt(self, volume) -> str:
+        return (
+            f"# {volume.title}"
+            + self.config.paragraph_separator
+            + self.config.paragraph_separator.join(
+                [
+                    self._to_chapter_txt(chapter, True)
+                    for chapter in volume.chapters
+                ]
+            )
+        )
+
+    def _to_chapter_txt(self, chapter, part_of_volume=False) -> str:
+        header = "##" if part_of_volume else "#"
+        return (
+            f"{header} {chapter.title}"
+            + self.config.paragraph_separator
+            + self.config.paragraph_separator.join(chapter.paragraphs)
+        )
+
+    def _to_volume_chapter_txt(self, volume, chapter) -> str:
+        return (
+            f"# {volume.title} {chapter.title}"
+            + self.config.paragraph_separator
+            + self.config.paragraph_separator.join(chapter.paragraphs)
+        )

txt2ebook-0.1.158/src/txt2ebook/formats/txt.py

@@ -0,0 +1,169 @@
+# Copyright (c) 2021,2022,2023,2024,2025 Kian-Meng Ang
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+"""Convert and backup source text file into text as well."""
+
+import logging
+import shutil
+from datetime import datetime as dt
+from pathlib import Path
+
+from txt2ebook.formats.base import BaseWriter
+from txt2ebook.helpers import lower_underscore
+from txt2ebook.models import Chapter, Volume
+
+logger = logging.getLogger(__name__)
+
+
+class TxtWriter(BaseWriter):
+    """Module for writing ebook in txt format."""
+
+    def write(self) -> None:
+        """Optionally backup and overwrite the txt file.
+
+        If the input content came from stdin, we'll skip backup and overwrite
+        source text file.
+        """
+        if self.config.input_file.name == "<stdin>":
+            logger.info("Skip backup source text file as content from stdin")
+        elif self.config.split_volume_and_chapter:
+            self._export_multiple_files()
+        else:
+            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)
+
+            with open(output_filename, "w", encoding="utf8") as file:
+                logger.info("Generate TXT file: %s", output_filename.resolve())
+                file.write(self._to_txt())
+
+            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") + 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,
+                lower_underscore(
+                    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,
+                lower_underscore(
+                    (
+                        f"{section_seq}"
+                        f"_{chapter_seq}"
+                        f"_{txt_filename.stem}"
+                        f"_{volume.title}"
+                        f"_{chapter.title}"
+                        f"{extension}"
+                    )
+                ),
+            )
+        )
+
+    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}")
+                ),
+            )
+        )
+
+    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):
+                content.append(self._to_volume_txt(section))
+            if isinstance(section, Chapter):
+                content.append(self._to_chapter_txt(section))
+
+        return f"{self.config.paragraph_separator}".join(content)
+
+    def _to_volume_txt(self, volume) -> str:
+        return (
+            volume.title
+            + self.config.paragraph_separator
+            + self.config.paragraph_separator.join(
+                [self._to_chapter_txt(chapter) for chapter in volume.chapters]
+            )
+        )
+
+    def _to_chapter_txt(self, chapter) -> str:
+        return (
+            chapter.title
+            + self.config.paragraph_separator
+            + self.config.paragraph_separator.join(chapter.paragraphs)
+        )
+
+    def _to_volume_chapter_txt(self, volume, chapter) -> str:
+        return (
+            volume.title
+            + " "
+            + chapter.title
+            + self.config.paragraph_separator
+            + self.config.paragraph_separator.join(chapter.paragraphs)
+        )