decksmith 0.9.1__py3-none-any.whl → 0.9.3__py3-none-any.whl

decksmith/card_builder.py

@@ -4,6 +4,7 @@ which is used to create card images based on a YAML specification.
 """
 
 import operator
+import traceback
 from pathlib import Path
 from typing import Any, Dict, Optional, Tuple
 
@@ -52,14 +53,17 @@ class CardBuilder:
 
     def _calculate_absolute_position(self, element: Dict[str, Any]) -> Tuple[int, int]:
         """
-        Calculates the absolute position of an element,
-        resolving relative positioning.
+        Calculates the absolute position of an element, resolving relative positioning.
+
         Args:
             element (dict): The element dictionary.
+
         Returns:
             tuple: The absolute (x, y) position of the element.
+
+        Raises:
+            ValueError: If the referenced element for relative positioning is not found.
         """
-        # If the element has no 'relative_to', return its position directly
         if "relative_to" not in element:
             return tuple(element.get("position", [0, 0]))
 
@@ -85,53 +89,80 @@ class CardBuilder:
     def render(self) -> Image.Image:
         """
         Renders the card image by drawing all elements specified in the YAML.
+
         Returns:
             Image.Image: The rendered card image.
+
+        Raises:
+            Exception: If an error occurs during rendering.
         """
         self.spec = transform_card(self.spec)
         validate_card(self.spec)
 
+        renderers = {
+            "text": self._render_text,
+            "image": self._render_image,
+            "circle": self._render_shape,
+            "ellipse": self._render_shape,
+            "polygon": self._render_shape,
+            "regular-polygon": self._render_shape,
+            "rectangle": self._render_shape,
+        }
+
         for element in self.spec.get("elements", []):
             element_type = element.get("type")
-            try:
-                if element_type == "text":
-                    self.text_renderer.render(
-                        self.draw,
-                        element,
-                        self._calculate_absolute_position,
-                        self._store_element_position,
-                    )
-                elif element_type == "image":
-                    self.image_renderer.render(
-                        self.card,
-                        element,
-                        self._calculate_absolute_position,
-                        self._store_element_position,
-                    )
-                elif element_type in [
-                    "circle",
-                    "ellipse",
-                    "polygon",
-                    "regular-polygon",
-                    "rectangle",
-                ]:
-                    self.card = self.shape_renderer.render(
-                        self.card,
-                        element,
-                        self._calculate_absolute_position,
-                        self._store_element_position,
+            handler = renderers.get(element_type)
+
+            if handler:
+                try:
+                    handler(element)
+                except Exception as exc:
+                    logger.error(
+                        "Error drawing element %s: %s\n%s",
+                        element_type,
+                        exc,
+                        traceback.format_exc(),
                     )
-                    # Re-create draw object because shape renderer might have composited a new image
-                    self.draw = ImageDraw.Draw(self.card, "RGBA")
-            except Exception as e:
-                logger.error("Error drawing element %s: %s", element_type, e)
-                # Continue drawing other elements
+                    raise
+            else:
+                logger.warning("Unknown element type: %s", element_type)
 
         return self.card
 
+    def _render_text(self, element: Dict[str, Any]):
+        """Renders a text element."""
+        self.card = self.text_renderer.render(
+            self.card,
+            element,
+            self._calculate_absolute_position,
+            self._store_element_position,
+        )
+        self.draw = ImageDraw.Draw(self.card, "RGBA")
+
+    def _render_image(self, element: Dict[str, Any]):
+        """Renders an image element."""
+        self.image_renderer.render(
+            self.card,
+            element,
+            self._calculate_absolute_position,
+            self._store_element_position,
+        )
+
+    def _render_shape(self, element: Dict[str, Any]):
+        """Renders a shape element."""
+        self.card = self.shape_renderer.render(
+            self.card,
+            element,
+            self._calculate_absolute_position,
+            self._store_element_position,
+        )
+        # Re-create draw object because shape renderer might have composited a new image
+        self.draw = ImageDraw.Draw(self.card, "RGBA")
+
     def build(self, output_path: Path):
         """
         Builds the card image and saves it to the specified path.
+
         Args:
             output_path (Path): The path where the card image will be saved.
         """

decksmith/deck_builder.py

@@ -1,85 +1,95 @@
-"""
-This module contains the DeckBuilder class,
-which is used to create a deck of cards based on a YAML specification
-and a CSV file.
-"""
-
-import concurrent.futures
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-import pandas as pd
-from pandas import Series
-from ruamel.yaml import YAML
-
-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 YAML specification and a CSV file.
-    Attributes:
-        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: Optional[Path] = None):
-        """
-        Initializes the DeckBuilder with a YAML specification file and a CSV file.
-        Args:
-            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
-
-    @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():
-            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
-
-        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]):
-            """
-            Builds a single card from a row of the CSV file.
-            Args:
-                row_tuple (tuple[int, Series]): A tuple containing the row index and the row data.
-            """
-            idx, row = row_tuple
-            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, dataframe.iterrows()))
+"""
+This module contains the DeckBuilder class,
+which is used to create a deck of cards based on a YAML specification
+and a CSV file.
+"""
+
+import concurrent.futures
+import traceback
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+from pandas import Series
+from ruamel.yaml import YAML
+
+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 YAML specification and a CSV file.
+    Attributes:
+        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: Optional[Path] = None):
+        """
+        Initializes the DeckBuilder with a YAML specification file and a CSV file.
+        Args:
+            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
+
+    @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.
+
+        Args:
+            output_path (Path): The directory path to save the built cards.
+        """
+        base_path = self.spec_path.parent if self.spec_path else None
+
+        if not self.csv_path or not self.csv_path.exists():
+            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
+
+        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\n%s", e, traceback.format_exc())
+            return
+
+        def build_card(row_tuple: tuple[int, Series]):
+            """
+            Builds a single card from a row of the CSV file.
+            Args:
+                row_tuple (tuple[int, Series]): A tuple containing the row index and the row data.
+            """
+            idx, row = row_tuple
+            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 exc:
+                logger.error(
+                    "Error building card %s: %s\n%s",
+                    idx + 1,
+                    exc,
+                    traceback.format_exc(),
+                )
+                raise
+
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            list(executor.map(build_card, dataframe.iterrows()))

decksmith/export.py

@@ -2,6 +2,7 @@
 This module provides the functionality to export images from a folder to a PDF file.
 """
 
+import traceback
 from pathlib import Path
 from typing import List, Tuple
 
@@ -166,5 +167,7 @@ class PdfExporter:
             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)
+            logger.error(
+                "An error occurred during PDF export: %s\n%s", e, traceback.format_exc()
+            )
             raise

decksmith/gui/app.py

@@ -8,6 +8,7 @@ import os
 import signal
 import threading
 import time
+import traceback
 import webbrowser
 from io import StringIO
 from pathlib import Path
@@ -96,8 +97,8 @@ def get_default_path():
         default_path.mkdir(parents=True, exist_ok=True)
         return jsonify({"path": str(default_path)})
     except Exception as e:
-        logger.error("Error creating default path: %s", e)
-        return jsonify({"error": str(e)}), 500
+        logger.error("Error creating default path: %s\n%s", e, traceback.format_exc())
+        return jsonify({"status": "error", "message": str(e)}), 500
 
 
 @app.route("/api/system/browse", methods=["POST"])
@@ -115,23 +116,26 @@ def browse_folder():
             return jsonify({"path": folder_path})
         return jsonify({"path": None})
     except ImportError as e:
-        logger.error("crossfiledialog import failed: %s", e)
-        return jsonify({"error": f"Browse feature unavailable: {e}"}), 501
+        logger.error("crossfiledialog import failed: %s\n%s", e, traceback.format_exc())
+        return jsonify(
+            {"status": "error", "message": f"Browse feature unavailable: {e}"}
+        ), 501
     except Exception as e:
-        logger.error("Error browsing folder: %s", e)
-        return jsonify({"error": str(e)}), 500
+        logger.error("Error browsing folder: %s\n%s", e, traceback.format_exc())
+        return jsonify({"status": "error", "message": str(e)}), 500
 
 
 @app.route("/api/project/select", methods=["POST"])
 def select_project():
     """Selects a project directory."""
-    path_str = request.json.get("path")
+    data = request.json or {}
+    path_str = data.get("path")
     if not path_str:
-        return jsonify({"error": "Path is required"}), 400
+        return jsonify({"status": "error", "message": "Path is required"}), 400
 
     path = Path(path_str)
     if not path.exists() or not path.is_dir():
-        return jsonify({"error": "Directory does not exist"}), 400
+        return jsonify({"status": "error", "message": "Directory does not exist"}), 400
 
     project_manager.set_working_dir(path)
     return jsonify({"status": "success", "path": str(path)})
@@ -147,9 +151,10 @@ def close_project():
 @app.route("/api/project/create", methods=["POST"])
 def create_project():
     """Creates a new project."""
-    path_str = request.json.get("path")
+    data = request.json or {}
+    path_str = data.get("path")
     if not path_str:
-        return jsonify({"error": "Path is required"}), 400
+        return jsonify({"status": "error", "message": "Path is required"}), 400
 
     path = Path(path_str)
 
@@ -157,8 +162,8 @@ def create_project():
         project_manager.create_project(path)
         return jsonify({"status": "success", "path": str(path)})
     except Exception as e:
-        logger.error("Error creating project: %s", e)
-        return jsonify({"error": str(e)}), 500
+        logger.error("Error creating project: %s\n%s", e, traceback.format_exc())
+        return jsonify({"status": "error", "message": str(e)}), 500
 
 
 @app.route("/api/load", methods=["GET"])
@@ -172,7 +177,7 @@ def load_files():
 def save_files():
     """Saves project files."""
     if project_manager.get_working_dir() is None:
-        return jsonify({"error": "No project selected"}), 400
+        return jsonify({"status": "error", "message": "No project selected"}), 400
 
     data = request.json
     yaml_content = data.get("yaml")
@@ -182,8 +187,8 @@ def save_files():
         project_manager.save_files(yaml_content, csv_content)
         return jsonify({"status": "success"})
     except Exception as e:
-        logger.error("Error saving files: %s", e)
-        return jsonify({"error": str(e)}), 500
+        logger.error("Error saving files: %s\n%s", e, traceback.format_exc())
+        return jsonify({"status": "error", "message": str(e)}), 500
 
 
 @app.route("/api/cards", methods=["GET"])
@@ -201,7 +206,7 @@ def list_cards():
         csv_table = pd.read_csv(csv_path, sep=";")
         return jsonify(csv_table.to_dict(orient="records"))
     except Exception as e:
-        logger.error("Error listing cards: %s", e)
+        logger.error("Error listing cards: %s\n%s", e, traceback.format_exc())
         return jsonify({"error": str(e)}), 400
 
 
@@ -242,7 +247,7 @@ def preview_card(card_index):
         return send_file(image_buffer, mimetype="image/png")
 
     except Exception as e:
-        logger.error("Error previewing card: %s", e)
+        logger.error("Error previewing card: %s\n%s", e, traceback.format_exc())
         return jsonify({"error": str(e)}), 500
 
 
@@ -271,7 +276,7 @@ def build_deck():
 
         return jsonify({"status": "success", "message": f"Deck built in {output_path}"})
     except Exception as e:
-        logger.error("Error building deck: %s", e)
+        logger.error("Error building deck: %s\n%s", e, traceback.format_exc())
         return jsonify({"error": str(e)}), 500
 
 
@@ -313,7 +318,7 @@ def export_pdf():
             {"status": "success", "message": f"PDF exported to {output_pdf}"}
         )
     except Exception as e:
-        logger.error("Error exporting PDF: %s", e)
+        logger.error("Error exporting PDF: %s\n%s", e, traceback.format_exc())
         return jsonify({"error": str(e)}), 500