bookcraft 0.1.0__tar.gz

bookcraft-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.3
+Name: bookcraft
+Version: 0.1.0
+Summary: A PDF book generator for structured ritual and ceremonial texts
+Author: Albert Kolozsvari
+Author-email: albertartk@gmail.com
+Requires-Python: >=3.11.0,<4.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: PyYAML (>=6.0.2)
+Requires-Dist: fpdf2 (>=2.8.5,<3.0.0)
+Requires-Dist: typing-extensions (>=4.15.0,<5.0.0)
+Description-Content-Type: text/markdown
+
+# bookcraft
+
+A Python library for generating PDF books from structured text content.
+
+## Installation
+
+```bash
+pip install bookcraft
+```
+
+## Usage
+
+```python
+from bookcraft import generate
+
+generate(
+    books_path="./books/",
+    settings_path="./c-settings.yaml",
+    fonts_path="./fonts.yaml",
+    keywords_path="./c-keywords.yaml",
+    output_path="./output/craft.pdf",
+    mode="craft",
+)
+```
+
+### Modes
+
+| Mode | Description |
+|------|-------------|
+| `craft` | Craft, light theme |
+| `craft-dark` | Craft, dark theme |
+| `ra` | Royal Arch, light theme |
+| `ra-dark` | Royal Arch, dark theme |
+
+## Content layout
+
+Your content project should provide:
+
+```
+your-project/
+├── books/          # directories of page-N.txt files
+├── fonts/          # font files referenced in fonts.yaml
+├── fonts.yaml
+├── c-settings.yaml
+├── c-keywords.yaml
+├── ra-settings.yaml
+├── ra-keywords.yaml
+└── output/         # generated PDFs written here
+```
+

bookcraft-0.1.0/README.md

@@ -0,0 +1,49 @@
+# bookcraft
+
+A Python library for generating PDF books from structured text content.
+
+## Installation
+
+```bash
+pip install bookcraft
+```
+
+## Usage
+
+```python
+from bookcraft import generate
+
+generate(
+    books_path="./books/",
+    settings_path="./c-settings.yaml",
+    fonts_path="./fonts.yaml",
+    keywords_path="./c-keywords.yaml",
+    output_path="./output/craft.pdf",
+    mode="craft",
+)
+```
+
+### Modes
+
+| Mode | Description |
+|------|-------------|
+| `craft` | Craft, light theme |
+| `craft-dark` | Craft, dark theme |
+| `ra` | Royal Arch, light theme |
+| `ra-dark` | Royal Arch, dark theme |
+
+## Content layout
+
+Your content project should provide:
+
+```
+your-project/
+├── books/          # directories of page-N.txt files
+├── fonts/          # font files referenced in fonts.yaml
+├── fonts.yaml
+├── c-settings.yaml
+├── c-keywords.yaml
+├── ra-settings.yaml
+├── ra-keywords.yaml
+└── output/         # generated PDFs written here
+```

bookcraft-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[tool.poetry]
+name = "bookcraft"
+version = "0.1.0"
+description = "A PDF book generator for structured ritual and ceremonial texts"
+authors = ["Albert Kolozsvari <albertartk@gmail.com>"]
+readme = "README.md"
+packages = [{include = "bookcraft", from = "src"}]
+
+[tool.poetry.dependencies]
+python = "^3.11.0"
+PyYAML = ">=6.0.2"
+fpdf2 = "^2.8.5"
+typing-extensions = "^4.15.0"
+
+[tool.poetry.scripts]
+bookcraft = "bookcraft.cli:main"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

bookcraft-0.1.0/src/bookcraft/__init__.py

@@ -0,0 +1,3 @@
+from bookcraft._generate import generate
+
+__all__ = ["generate"]

bookcraft-0.1.0/src/bookcraft/_generate.py

@@ -0,0 +1,48 @@
+from bookcraft.book import Book
+from bookcraft.cell.CellFactory import CellFactory
+from bookcraft.config import load_config
+from bookcraft.cursor.CursorModifierFactory import CursorModifierFactory
+from bookcraft.cursor.CursorModifierProcessor import CursorModifierProcessor
+from bookcraft.cursor.CursorModifierReducer import CursorModifierReducer
+from bookcraft.helpers import get_files
+
+_SWITCH_MAP = {
+    "craft": "c-",
+    "craft-dark": "c-dark-",
+    "ra": "ra-",
+    "ra-dark": "ra-dark-",
+}
+
+
+def generate(
+    books_path: str,
+    settings_path: str,
+    fonts_path: str,
+    keywords_path: str,
+    output_path: str,
+    mode: str = "craft",
+) -> None:
+    if mode not in _SWITCH_MAP:
+        raise ValueError(f"Unknown mode '{mode}'. Choose from: {', '.join(_SWITCH_MAP)}")
+
+    switch = _SWITCH_MAP[mode]
+    config = load_config(books_path, settings_path, fonts_path, keywords_path, switch)
+
+    book = Book(config)
+    book.set_title(config.SETTINGS["title"]["text"])
+    book.set_book_font(config.FONTS)
+
+    for book_title in config.SETTINGS["books"]:
+        if config.is_dark:
+            book.page_background = (18, 18, 18)
+
+        book.set_path(books_path + book_title)
+        book.set_margin(config.PAGE)
+        book.set_subject(book_title)
+        book.set_cm_factory(CursorModifierFactory())
+        book.set_cell_factory(CellFactory())
+        book.set_cm_processor(CursorModifierProcessor())
+        book.set_cm_reducer(CursorModifierReducer())
+        book.set_pages(get_files(books_path + book_title))
+
+    book.build(output_path)

bookcraft-0.1.0/src/bookcraft/book.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from fpdf import FPDF
+
+from bookcraft.cell.CellFactory import CellFactory
+from bookcraft.config import Config
+from bookcraft.cursor.CursorModifierFactory import CursorModifierFactory
+from bookcraft.cursor.CursorModifierProcessor import CursorModifierProcessor
+from bookcraft.cursor.CursorModifierReducer import CursorModifierReducer
+from bookcraft.helpers import get_pages
+from bookcraft.models import Cell, Context, CursorModifier, Page
+
+
+class Book(FPDF):
+    def __init__(self, config: Config) -> Book:
+        self.config = config
+        format = (535, 785) if config.is_ra else (475, 785)
+        super().__init__(unit="pt", format=format)
+        self._page_subjects = {}
+
+    def header(self) -> None:
+        subject = self._page_subjects.get(self.page_no(), self.subject)
+        if "Cover" in subject and self.config.is_ra:
+            return
+
+        page_no = self.page_no() + 22 if self.config.is_ra else self.page_no() - 5
+        self.set_font(**self.config.TEMPLATE_FONT)
+        self.set_text_color(*self.config.TEMPLATE_COLOR)
+        self.set_draw_color(*self.config.TEMPLATE_COLOR)
+        width = self.w - self.l_margin - self.r_margin
+        height = self.config.TEMPLATE_HEIGHT
+        page_no_width = self.get_string_width(f"{page_no}")
+
+        # Use per-page subject if available
+        subject = self._page_subjects.get(self.page_no(), self.subject)
+        subject_width = self.get_string_width(subject)
+
+        line_start = self.r_margin
+        line_end = self.w - self.r_margin
+
+        if page_no > 0 and page_no < 150:
+            self.cell(subject_width, height, subject)
+            self.cell(width - page_no_width - subject_width, height, "", 0)
+            self.cell(page_no_width, height, f"{page_no}", 0, 1)
+            self.cell(width, height, "", 0, 1)
+            self.dashed_line(line_start, self.y, line_end, self.y, 3, 3)
+            self.cell(width, height, "", 0, 1)
+            self.cell(width, height / 2, "", 0, 1)
+
+    def set_path(self, book_path: str) -> Book:
+        self.book_path = book_path
+
+        return self
+
+    def set_book_font(self, fonts: dict) -> Book:
+        [self.add_font(**font, uni=True) for font in fonts]
+
+        return self
+
+    def set_margin(self, page: dict) -> Book:
+        self.set_top_margin(page["top_margin"])
+        self.set_left_margin(page["margin_size"])
+        self.set_right_margin(page["margin_size"])
+        self.set_auto_page_break(True, page["bottom_margin"])
+        self.c_margin = 0
+
+        return self
+
+    def set_title(self, title: str) -> Book:
+        title = title.split("/")[-1]
+        super().set_title(title)
+
+        return self
+
+    def set_subject(self, subject: str) -> Book:
+        subject = subject.split("/")[-1]
+        super().set_subject(subject)
+        # Mark all future pages with this subject until changed
+        self._current_subject = subject
+        return self
+
+    def set_cm_reducer(self, cm_reducer: CursorModifierReducer) -> Book:
+        self.cm_reducer = cm_reducer
+
+        return self
+
+    def set_cm_processor(self, cm_processor: CursorModifierProcessor) -> Book:
+        self.cm_processor = cm_processor
+
+        return self
+
+    def set_cm_factory(self, cm_factory: CursorModifierFactory) -> Book:
+        self.cm_factory = cm_factory
+
+        return self
+
+    def set_cell_factory(self, cell_factory: CellFactory) -> Book:
+        self.cell_factory = cell_factory
+
+        return self
+
+    def set_pages(self, pages: list[Page]) -> Book:
+        self.modifiers: list[CursorModifier] = []
+
+        for page_index in range(1, len(pages) + 1):
+            memory = get_pages(self.book_path, page_index, 2)
+            self._print_page(memory)
+            # After adding a page, record the subject for that page number
+            self._page_subjects[self.page_no()] = getattr(self, "_current_subject", getattr(self, "subject", ""))
+
+        return self
+
+    def build(self, output_path: str) -> None:
+        self.output(output_path)
+
+    def _print_page(self, memory: list[Page]) -> list[CursorModifier]:
+        self.add_page()
+
+        page = memory[0]
+        for i in range(len(page)):
+            line = page[i]
+            body = []
+
+            for j in range(len(line)):
+                # get previous cell cursor
+                cursor = self.cm_reducer.reduce(self.modifiers)
+                context = Context(i, j, memory, self.config, cursor)
+
+                new_cms = self.cm_factory.resolve(context)
+                self.modifiers.extend(new_cms)
+                self.modifiers = self.cm_processor.process(self.modifiers)
+
+                # get current cell cursor
+                cursor = self.cm_reducer.reduce(self.modifiers)
+                context = Context(i, j, memory, self.config, cursor)
+
+                # get new cells
+                cells = self.cell_factory.create_cells(context)
+
+                if not cells:
+                    continue
+
+                body.extend(cells)
+
+            self._print_line(body, line)
+
+    def _print_line(self, cells: list[Cell], memory_line: list[str]) -> None:
+        cells = self._justify_line(cells, memory_line)
+        for cell in cells:
+            cursor = cell.cursor
+            self.set_font(cursor.family, cursor.style, cursor.size)
+            self.set_text_color(*cursor.colour)
+            if cursor.fill is not None:
+                self.set_fill_color(*cursor.fill)
+                self.set_draw_color(*cursor.fill)
+            else:
+                cell.has_fill = False
+
+            self.cell(
+                w=cell.width,
+                h=cell.height,
+                txt=cell.text,
+                ln=cell.has_break,
+                fill=cell.has_fill,
+            )
+
+    def _justify_line(self, cells: list[Cell], memory_line: list[str]) -> list[Cell]:
+        width = self.w - self.l_margin - self.r_margin
+        clean_line_w = 0
+        for cell in cells:
+            cursor = cell.cursor
+            self.set_font(cursor.family, cursor.style, cursor.size)
+            cell.width = self.get_string_width(cell.text)
+            if cell.text != " ":
+                clean_line_w += cell.width
+
+        char_check = any([char in memory_line for char in ["=", "#"]])
+        if memory_line.count(" ") and not char_check:
+            space_width = (width - clean_line_w) / memory_line.count(" ")
+            for cell in cells:
+                if cell.text == " ":
+                    cell.width = space_width
+
+        for cell in cells:
+            if cell.text == "^":
+                cell.text = " "
+
+        return cells

bookcraft-0.1.0/src/bookcraft/cell/CellFactory.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+
+from bookcraft.cell.rules.BreakLineRule import BreakLineRule
+from bookcraft.cell.rules.CharRule import CharRule
+from bookcraft.cell.rules.HeaderSpacingRule import HeaderSpacingRule
+from bookcraft.cell.rules.Rule import CellRule, CellSpecificationRule
+from bookcraft.models import Cell, Context
+from bookcraft.specs.FirstLineSpecification import FirstLineSpecification
+from bookcraft.specs.IsCharEqualSpecification import IsCharEqualSpecification
+from bookcraft.specs.IsEndOfLineSpecification import IsEndOfLineSpecification
+from bookcraft.specs.LineHasCharSpecification import LineHasCharSpecification
+from bookcraft.specs.Specification import AndSpecification, NotSpecification
+
+
+@dataclass
+class CellFactory:
+    rules: tuple[CellRule, ...] = (
+        CellSpecificationRule(
+            AndSpecification(
+                NotSpecification(LineHasCharSpecification(["#"], -1)),
+                IsCharEqualSpecification(["#"]),
+                NotSpecification(FirstLineSpecification()),
+            ),
+            HeaderSpacingRule(),
+        ),
+        CellSpecificationRule(
+            NotSpecification(
+                IsCharEqualSpecification(["#", ">", "$", "<", "=", "%", "&"])
+            ),
+            CharRule(),
+        ),
+        CellSpecificationRule(
+            IsEndOfLineSpecification(),
+            BreakLineRule(),
+        ),
+        CellSpecificationRule(
+            AndSpecification(
+                IsEndOfLineSpecification(),
+                LineHasCharSpecification(["#"], 0),
+                NotSpecification(LineHasCharSpecification(["#"], 1)),
+            ),
+            HeaderSpacingRule(),
+        ),
+    )
+
+    def create_cells(self, context: Context) -> list[Cell]:
+        cells = []
+        for rule in self.rules:
+            cell = rule.apply(context)
+
+            if cell is None:
+                continue
+
+            cells.append(cell)
+
+        return cells

bookcraft-0.1.0/src/bookcraft/cell/rules/BreakLineRule.py

@@ -0,0 +1,14 @@
+from bookcraft.cell.rules.Rule import CellRule
+from bookcraft.models import Cell, Context
+
+
+class BreakLineRule(CellRule):
+    def apply(self, context: Context) -> Cell:
+        CONFIG = context.config
+        return Cell(
+            width=0,
+            height=CONFIG.DEFAULT_HEIGHT,
+            text="",
+            has_break=True,
+            cursor=context.cursor,
+        )

bookcraft-0.1.0/src/bookcraft/cell/rules/CharRule.py

@@ -0,0 +1,17 @@
+from bookcraft.cell.rules.Rule import CellRule
+from bookcraft.models import Cell, Context
+
+
+class CharRule(CellRule):
+    def apply(self, context: Context) -> Cell:
+        CONFIG = context.config
+        page = context.memory[0]
+        char = page[context.i][context.j]
+
+        return Cell(
+            width=0,
+            height=CONFIG.DEFAULT_HEIGHT,
+            text=char,
+            cursor=context.cursor,
+            has_fill=True,
+        )

bookcraft-0.1.0/src/bookcraft/cell/rules/HeaderSpacingRule.py

@@ -0,0 +1,14 @@
+from bookcraft.cell.rules.Rule import CellRule
+from bookcraft.models import Cell, Context
+
+
+class HeaderSpacingRule(CellRule):
+    def apply(self, context: Context) -> Cell:
+        CONFIG = context.config
+        return Cell(
+            width=0,
+            height=CONFIG.HEADING_SPACING_HEIGHT,
+            text="",
+            has_break=True,
+            cursor=context.cursor,
+        )

bookcraft-0.1.0/src/bookcraft/cell/rules/Rule.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from bookcraft.models import Cell, Context
+from bookcraft.specs.Specification import Specification
+
+
+class CellRule(ABC):
+    @abstractmethod
+    def apply(self, context: Context) -> Cell:
+        pass
+
+
+class CellSpecificationRule(CellRule):
+    def __init__(self, specification: Specification, rule: CellRule) -> None:
+        self.specification = specification
+        self.rule = rule
+
+    def apply(self, context: Context) -> Optional[Cell]:
+        if self.specification.is_satisfied(context):
+            return self.rule.apply(context)
+
+        return None

bookcraft-0.1.0/src/bookcraft/cli.py

@@ -0,0 +1,23 @@
+import argparse
+
+from bookcraft._generate import generate, _SWITCH_MAP
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Generate a PDF book with bookcraft.")
+    parser.add_argument("mode", choices=list(_SWITCH_MAP), help="Rendering mode")
+    parser.add_argument("--books", required=True, help="Path to books directory")
+    parser.add_argument("--settings", required=True, help="Path to settings YAML")
+    parser.add_argument("--fonts", required=True, help="Path to fonts YAML")
+    parser.add_argument("--keywords", required=True, help="Path to keywords YAML")
+    parser.add_argument("--output", required=True, help="Output PDF path")
+    args = parser.parse_args()
+
+    generate(
+        books_path=args.books,
+        settings_path=args.settings,
+        fonts_path=args.fonts,
+        keywords_path=args.keywords,
+        output_path=args.output,
+        mode=args.mode,
+    )

bookcraft-0.1.0/src/bookcraft/config.py

@@ -0,0 +1,134 @@
+from dataclasses import dataclass
+
+import yaml
+
+
+@dataclass
+class Config:
+    BOOKS_PATH: str
+    FONTS: dict
+    SETTINGS: dict
+    KEYWORDS: list
+    switch: str  # "c-", "c-dark-", "ra-", "ra-dark-"
+
+    @property
+    def is_dark(self) -> bool:
+        return "dark" in self.switch
+
+    @property
+    def is_ra(self) -> bool:
+        return "ra" in self.switch
+
+    @property
+    def PAGE(self) -> dict:
+        return self.SETTINGS.get("page")
+
+    @property
+    def COLOUR(self) -> dict:
+        return self.SETTINGS.get("colour")
+
+    @property
+    def ROLES(self) -> dict:
+        return self.SETTINGS.get("roles")
+
+    @property
+    def TEXT(self) -> dict:
+        return self.SETTINGS.get("text")
+
+    @property
+    def DEFAULT_CURSOR(self) -> dict:
+        return {
+            "family": self.TEXT["default"]["cursor"]["family"],
+            "style": self.TEXT["default"]["cursor"]["style"],
+            "size": self.TEXT["default"]["cursor"]["size"],
+            "colour": self.TEXT["default"]["cursor"]["colour"],
+            "fill": self.TEXT["default"]["cursor"]["fill"],
+        }
+
+    @property
+    def DEFAULT_FONT(self) -> dict:
+        return {
+            "family": self.TEXT["default"]["cursor"]["family"],
+            "style": self.TEXT["default"]["cursor"]["style"],
+            "size": self.TEXT["default"]["cursor"]["size"],
+        }
+
+    @property
+    def DEFAULT_HEIGHT(self) -> dict:
+        return self.TEXT["default"]["height"]
+
+    @property
+    def DEFAULT_FILL(self) -> dict:
+        return self.TEXT["default"]["cursor"]["fill"]
+
+    @property
+    def TEMPLATE_FONT(self) -> dict:
+        return {
+            "family": self.TEXT["template"]["cursor"]["family"],
+            "style": self.TEXT["template"]["cursor"]["style"],
+            "size": self.TEXT["template"]["cursor"]["size"],
+        }
+
+    @property
+    def TEMPLATE_COLOR(self) -> dict:
+        return self.TEXT["template"]["cursor"]["colour"]
+
+    @property
+    def TEMPLATE_HEIGHT(self) -> int:
+        return self.TEXT["template"]["height"]
+
+    @property
+    def BOLD_CURSOR(self) -> dict:
+        return {
+            "family": self.TEXT["bold"]["cursor"]["family"],
+            "style": self.TEXT["bold"]["cursor"]["style"],
+            "size": self.TEXT["bold"]["cursor"]["size"],
+            "colour": self.TEXT["bold"]["cursor"]["colour"],
+            "fill": self.TEXT["bold"]["cursor"]["fill"],
+        }
+
+    @property
+    def ITALIC_CURSOR(self) -> dict:
+        return {
+            "family": self.TEXT["italic"]["cursor"]["family"],
+            "style": self.TEXT["italic"]["cursor"]["style"],
+            "size": self.TEXT["italic"]["cursor"]["size"],
+            "colour": self.TEXT["italic"]["cursor"]["colour"],
+            "fill": self.TEXT["italic"]["cursor"]["fill"],
+        }
+
+    @property
+    def HEADING_CURSOR(self) -> dict:
+        return {
+            "family": self.TEXT["heading"]["cursor"]["family"],
+            "style": self.TEXT["heading"]["cursor"]["style"],
+            "size": self.TEXT["heading"]["cursor"]["size"],
+            "colour": self.TEXT["heading"]["cursor"]["colour"],
+            "fill": self.TEXT["heading"]["cursor"]["fill"],
+        }
+
+    @property
+    def HEADING_SPACING_HEIGHT(self) -> int:
+        return self.TEXT["heading_spacing"]["height"]
+
+
+def load_config(
+    books_path: str,
+    settings_path: str,
+    fonts_path: str,
+    keywords_path: str,
+    switch: str,
+) -> Config:
+    with open(fonts_path, "r") as f:
+        fonts = yaml.safe_load(f).get("fonts")
+    with open(settings_path, "r") as f:
+        settings = yaml.safe_load(f)
+    with open(keywords_path, "r") as f:
+        keywords = yaml.safe_load(f).get("keywords")
+    return Config(
+        BOOKS_PATH=books_path,
+        FONTS=fonts,
+        SETTINGS=settings,
+        KEYWORDS=keywords,
+        switch=switch,
+    )