decksmith 0.1.15__py3-none-any.whl → 0.9.2__py3-none-any.whl

decksmith/deck_builder.py

@@ -1,87 +1,69 @@
 """
 This module contains the DeckBuilder class,
-which is used to create a deck of cards based on a JSON specification
+which is used to create a deck of cards based on a YAML specification
 and a CSV file.
 """
 
 import concurrent.futures
-import json
 from pathlib import Path
-from typing import Union, List, Dict, Any
+from typing import Any, Dict, List, Optional
 
 import pandas as pd
 from pandas import Series
+from ruamel.yaml import YAML
 
-from .card_builder import CardBuilder
+from decksmith.card_builder import CardBuilder
+from decksmith.logger import logger
+from decksmith.macro import MacroResolver
 
 
 class DeckBuilder:
     """
-    A class to build a deck of cards based on a JSON specification and a CSV file.
+    A class to build a deck of cards based on a YAML specification and a CSV file.
     Attributes:
-        spec_path (Path): Path to the JSON specification file.
+        spec_path (Path): Path to the YAML specification file.
         csv_path (Union[Path, None]): Path to the CSV file containing card data.
         cards (list): List of CardBuilder instances for each card in the deck.
     """
 
-    def __init__(self, spec_path: Path, csv_path: Union[Path, None] = None):
+    def __init__(self, spec_path: Path, csv_path: Optional[Path] = None):
         """
-        Initializes the DeckBuilder with a JSON specification file and a CSV file.
+        Initializes the DeckBuilder with a YAML specification file and a CSV file.
         Args:
-            spec_path (Path): Path to the JSON specification file.
+            spec_path (Path): Path to the YAML specification file.
             csv_path (Union[Path, None]): Path to the CSV file containing card data.
         """
         self.spec_path = spec_path
         self.csv_path = csv_path
         self.cards: List[CardBuilder] = []
+        self._spec_cache: Optional[Dict[str, Any]] = None
 
-    def _replace_macros(self, row: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Replaces %colname% macros in the card specification with values from the row.
-        Works recursively for nested structures.
-        Args:
-            row (dict): A dictionary representing a row from the CSV file.
-        Returns:
-            dict: The updated card specification with macros replaced.
-        """
-
-        def replace_in_value(value: Any) -> Any:
-            if isinstance(value, str):
-                stripped_value = value.strip()
-                # First, check for an exact macro match to preserve type
-                for key in row:
-                    if stripped_value == f"%{key}%":
-                        return row[key]  # Return the raw value, preserving type
-
-                # If no exact match, perform standard string replacement for all macros
-                for key, val in row.items():
-                    value = value.replace(f"%{key}%", str(val))
-                return value
-
-            if isinstance(value, list):
-                return [replace_in_value(v) for v in value]
-
-            if isinstance(value, dict):
-                return {k: replace_in_value(v) for k, v in value.items()}
-
-            return value
-
-        with open(self.spec_path, "r", encoding="utf-8") as f:
-            spec = json.load(f)
-        return replace_in_value(spec)
+    @property
+    def spec(self) -> Dict[str, Any]:
+        """Loads and caches the spec file."""
+        if self._spec_cache is None:
+            yaml = YAML()
+            with open(self.spec_path, "r", encoding="utf-8") as spec_file:
+                self._spec_cache = yaml.load(spec_file)
+        return self._spec_cache
 
     def build_deck(self, output_path: Path):
         """
         Builds the deck of cards by reading the CSV file and creating CardBuilder instances.
         """
+        base_path = self.spec_path.parent if self.spec_path else None
+
         if not self.csv_path or not self.csv_path.exists():
-            with open(self.spec_path, "r", encoding="utf-8") as f:
-                spec = json.load(f)
-            card_builder = CardBuilder(spec)
+            logger.info("No CSV file found. Building single card from spec.")
+            card_builder = CardBuilder(self.spec, base_path=base_path)
             card_builder.build(output_path / "card_1.png")
             return
 
-        df = pd.read_csv(self.csv_path, encoding="utf-8", sep=";", header=0)
+        try:
+            dataframe = pd.read_csv(self.csv_path, encoding="utf-8", sep=";", header=0)
+        except Exception as e:
+            logger.error("Error reading CSV file: %s", e)
+            return
 
         def build_card(row_tuple: tuple[int, Series]):
             """
@@ -90,12 +72,14 @@ class DeckBuilder:
                 row_tuple (tuple[int, Series]): A tuple containing the row index and the row data.
             """
             idx, row = row_tuple
-            spec = self._replace_macros(row.to_dict())
-            card_builder = CardBuilder(spec)
-            card_builder.build(output_path / f"card_{idx + 1}.png")
+            try:
+                # We need a deep copy of the spec for each card to avoid side effects
+                # But resolve_macros creates a new structure, so it should be fine
+                spec = MacroResolver.resolve(self.spec, row.to_dict())
+                card_builder = CardBuilder(spec, base_path=base_path)
+                card_builder.build(output_path / f"card_{idx + 1}.png")
+            except Exception as e:
+                logger.error("Error building card %s: %s", idx + 1, e)
 
         with concurrent.futures.ThreadPoolExecutor() as executor:
-            list(executor.map(build_card, df.iterrows()))
-
-        # for row_tuple in df.iterrows():
-        #     build_card(row_tuple)
+            list(executor.map(build_card, dataframe.iterrows()))

decksmith/export.py

@@ -1,168 +1,170 @@
-"""
-This module provides the functionality to export images from a folder to a PDF file.
-"""
-
-import logging
-from pathlib import Path
-from typing import List, Tuple
-
-from reportlab.lib.pagesizes import A4
-from reportlab.lib.units import mm
-from reportlab.pdfgen import canvas
-
-
-class PdfExporter:
-    """
-    A class to export images from a folder to a PDF file.
-    """
-
-    def __init__(
-        self,
-        image_folder: Path,
-        output_path: Path,
-        page_size_str: str = "A4",
-        image_width: float = 63,
-        image_height: float = 88,
-        gap: float = 0,
-        margins: Tuple[float, float] = (2, 2),
-    ):
-        self.image_folder = image_folder
-        self.image_paths = self._get_image_paths()
-        self.output_path = output_path
-        self.page_size = self._get_page_size(page_size_str)
-        self.image_width = image_width * mm
-        self.image_height = image_height * mm
-        self.gap = gap * mm
-        self.margins = (margins[0] * mm, margins[1] * mm)
-        self.pdf = canvas.Canvas(str(self.output_path), pagesize=self.page_size)
-
-    def _get_image_paths(self) -> List[Path]:
-        """
-        Scans the image folder and returns a list of image paths.
-
-        Returns:
-            List[str]: A sorted list of image paths.
-        """
-        image_extensions = {".png", ".jpg", ".jpeg", ".webp"}
-        return sorted(
-            [
-                p
-                for p in self.image_folder.iterdir()
-                if p.suffix.lower() in image_extensions
-            ]
-        )
-
-    def _get_page_size(self, page_size_str: str) -> Tuple[float, float]:
-        """
-        Returns the page size from a string.
-
-        Args:
-            page_size_str (str): The string representing the page size.
-
-        Returns:
-            Tuple[float, float]: The page size in points.
-        """
-        if page_size_str.lower() == "a4":
-            return A4
-        # Add other page sizes here if needed
-        return A4
-
-    def _calculate_layout(self, page_width: float, page_height: float):
-        """
-        Calculates the optimal layout for the images on the page.
-
-        Args:
-            page_width (float): The width of the page.
-            page_height (float): The height of the page.
-
-        Returns:
-            Tuple[int, int, bool]: The number of columns, rows, and if the layout is rotated.
-        """
-        best_fit = 0
-        best_layout = (0, 0, False)
-
-        for rotated in [False, True]:
-            img_w, img_h = (
-                (self.image_width, self.image_height)
-                if not rotated
-                else (self.image_height, self.image_width)
-            )
-
-            cols = int(
-                (page_width - 2 * self.margins[0] + self.gap) / (img_w + self.gap)
-            )
-            rows = int(
-                (page_height - 2 * self.margins[1] + self.gap) / (img_h + self.gap)
-            )
-
-            if cols * rows > best_fit:
-                best_fit = cols * rows
-                best_layout = (cols, rows, rotated)
-
-        return best_layout
-
-    def export(self):
-        """
-        Exports the images to a PDF file.
-        """
-        try:
-            page_width, page_height = self.page_size
-            cols, rows, rotated = self._calculate_layout(page_width, page_height)
-
-            if cols == 0 or rows == 0:
-                raise ValueError("The images are too large to fit on the page.")
-
-            img_w, img_h = (
-                (self.image_width, self.image_height)
-                if not rotated
-                else (self.image_height, self.image_width)
-            )
-
-            total_width = cols * img_w + (cols - 1) * self.gap
-            total_height = rows * img_h + (rows - 1) * self.gap
-            start_x = (page_width - total_width) / 2
-            start_y = (page_height - total_height) / 2
-
-            images_on_page = 0
-            for image_path in self.image_paths:
-                if images_on_page > 0 and images_on_page % (cols * rows) == 0:
-                    self.pdf.showPage()
-                    images_on_page = 0
-
-                row = images_on_page // cols
-                col = images_on_page % cols
-
-                x = start_x + col * (img_w + self.gap)
-                y = start_y + row * (img_h + self.gap)
-
-                if not rotated:
-                    self.pdf.drawImage(
-                        str(image_path),
-                        x,
-                        y,
-                        width=img_w,
-                        height=img_h,
-                        preserveAspectRatio=True,
-                    )
-                else:
-                    self.pdf.saveState()
-                    center_x = x + img_w / 2
-                    center_y = y + img_h / 2
-                    self.pdf.translate(center_x, center_y)
-                    self.pdf.rotate(90)
-                    self.pdf.drawImage(
-                        str(image_path),
-                        -img_h / 2,
-                        -img_w / 2,
-                        width=img_h,
-                        height=img_w,
-                        preserveAspectRatio=True,
-                    )
-                    self.pdf.restoreState()
-                images_on_page += 1
-
-            self.pdf.save()
-            logging.info("Successfully exported PDF to %s", self.output_path)
-        except Exception as e:
-            logging.error("An error occurred during PDF export: %s", e)
-            raise
+"""
+This module provides the functionality to export images from a folder to a PDF file.
+"""
+
+from pathlib import Path
+from typing import List, Tuple
+
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.units import mm
+from reportlab.pdfgen import canvas
+
+from decksmith.logger import logger
+
+
+class PdfExporter:
+    """
+    A class to export images from a folder to a PDF file.
+    """
+
+    def __init__(
+        self,
+        image_folder: Path,
+        output_path: Path,
+        page_size_str: str = "A4",
+        image_width: float = 63,
+        image_height: float = 88,
+        gap: float = 0,
+        margins: Tuple[float, float] = (2, 2),
+    ):
+        self.image_folder = image_folder
+        self.image_paths = self._get_image_paths()
+        self.output_path = output_path
+        self.page_size = self._get_page_size(page_size_str)
+        self.image_width = image_width * mm
+        self.image_height = image_height * mm
+        self.gap = gap * mm
+        self.margins = (margins[0] * mm, margins[1] * mm)
+        self.pdf = canvas.Canvas(str(self.output_path), pagesize=self.page_size)
+
+    def _get_image_paths(self) -> List[Path]:
+        """
+        Scans the image folder and returns a list of image paths.
+
+        Returns:
+            List[str]: A sorted list of image paths.
+        """
+        image_extensions = {".png", ".jpg", ".jpeg", ".webp"}
+        return sorted(
+            [
+                image_path
+                for image_path in self.image_folder.iterdir()
+                if image_path.suffix.lower() in image_extensions
+            ]
+        )
+
+    def _get_page_size(self, page_size_str: str) -> Tuple[float, float]:
+        """
+        Returns the page size from a string.
+
+        Args:
+            page_size_str (str): The string representing the page size.
+
+        Returns:
+            Tuple[float, float]: The page size in points.
+        """
+        if page_size_str.lower() == "a4":
+            return A4
+        # Add other page sizes here if needed
+        return A4
+
+    def _calculate_layout(self, page_width: float, page_height: float):
+        """
+        Calculates the optimal layout for the images on the page.
+
+        Args:
+            page_width (float): The width of the page.
+            page_height (float): The height of the page.
+
+        Returns:
+            Tuple[int, int, bool]: The number of columns, rows, and if the layout is rotated.
+        """
+        best_fit = 0
+        best_layout = (0, 0, False)
+
+        for rotated in [False, True]:
+            image_width, image_height = (
+                (self.image_width, self.image_height)
+                if not rotated
+                else (self.image_height, self.image_width)
+            )
+
+            cols = int(
+                (page_width - 2 * self.margins[0] + self.gap) / (image_width + self.gap)
+            )
+            rows = int(
+                (page_height - 2 * self.margins[1] + self.gap)
+                / (image_height + self.gap)
+            )
+
+            if cols * rows > best_fit:
+                best_fit = cols * rows
+                best_layout = (cols, rows, rotated)
+
+        return best_layout
+
+    def export(self):
+        """
+        Exports the images to a PDF file.
+        """
+        try:
+            page_width, page_height = self.page_size
+            cols, rows, rotated = self._calculate_layout(page_width, page_height)
+
+            if cols == 0 or rows == 0:
+                raise ValueError("The images are too large to fit on the page.")
+
+            image_width, image_height = (
+                (self.image_width, self.image_height)
+                if not rotated
+                else (self.image_height, self.image_width)
+            )
+
+            total_width = cols * image_width + (cols - 1) * self.gap
+            total_height = rows * image_height + (rows - 1) * self.gap
+            start_horizontal = (page_width - total_width) / 2
+            start_vertical = (page_height - total_height) / 2
+
+            images_on_page = 0
+            for image_path in self.image_paths:
+                if images_on_page > 0 and images_on_page % (cols * rows) == 0:
+                    self.pdf.showPage()
+                    images_on_page = 0
+
+                row = images_on_page // cols
+                col = images_on_page % cols
+
+                position_horizontal = start_horizontal + col * (image_width + self.gap)
+                position_vertical = start_vertical + row * (image_height + self.gap)
+
+                if not rotated:
+                    self.pdf.drawImage(
+                        str(image_path),
+                        position_horizontal,
+                        position_vertical,
+                        width=image_width,
+                        height=image_height,
+                        preserveAspectRatio=True,
+                    )
+                else:
+                    self.pdf.saveState()
+                    center_horizontal = position_horizontal + image_width / 2
+                    center_vertical = position_vertical + image_height / 2
+                    self.pdf.translate(center_horizontal, center_vertical)
+                    self.pdf.rotate(90)
+                    self.pdf.drawImage(
+                        str(image_path),
+                        -image_height / 2,
+                        -image_width / 2,
+                        width=image_height,
+                        height=image_width,
+                        preserveAspectRatio=True,
+                    )
+                    self.pdf.restoreState()
+                images_on_page += 1
+
+            self.pdf.save()
+            logger.info("Successfully exported PDF to %s", self.output_path)
+        except Exception as e:
+            logger.error("An error occurred during PDF export: %s", e)
+            raise