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

decksmith/deck_builder.py

@@ -1,101 +1,85 @@
-"""
-This module contains the DeckBuilder class,
-which is used to create a deck of cards based on a JSON specification
-and a CSV file.
-"""
-
-import concurrent.futures
-import json
-from pathlib import Path
-from typing import Union, List, Dict, Any
-
-import pandas as pd
-from pandas import Series
-
-from .card_builder import CardBuilder
-
-
-class DeckBuilder:
-    """
-    A class to build a deck of cards based on a JSON specification and a CSV file.
-    Attributes:
-        spec_path (Path): Path to the JSON 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):
-        """
-        Initializes the DeckBuilder with a JSON specification file and a CSV file.
-        Args:
-            spec_path (Path): Path to the JSON 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] = []
-
-    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)
-
-    def build_deck(self, output_path: Path):
-        """
-        Builds the deck of cards by reading the CSV file and creating CardBuilder instances.
-        """
-        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)
-            card_builder.build(output_path / "card_1.png")
-            return
-
-        df = pd.read_csv(self.csv_path, encoding="utf-8", sep=";", header=0)
-
-        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
-            spec = self._replace_macros(row.to_dict())
-            card_builder = CardBuilder(spec)
-            card_builder.build(output_path / f"card_{idx + 1}.png")
-
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            list(executor.map(build_card, df.iterrows()))
-
-        # for row_tuple in df.iterrows():
-        #     build_card(row_tuple)
+"""
+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()))

decksmith/export.py

@@ -2,7 +2,6 @@
 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
 
@@ -10,6 +9,8 @@ from reportlab.lib.pagesizes import A4
 from reportlab.lib.units import mm
 from reportlab.pdfgen import canvas
 
+from decksmith.logger import logger
+
 
 class PdfExporter:
     """
@@ -46,9 +47,9 @@ class PdfExporter:
         image_extensions = {".png", ".jpg", ".jpeg", ".webp"}
         return sorted(
             [
-                p
-                for p in self.image_folder.iterdir()
-                if p.suffix.lower() in image_extensions
+                image_path
+                for image_path in self.image_folder.iterdir()
+                if image_path.suffix.lower() in image_extensions
             ]
         )
 
@@ -82,17 +83,18 @@ class PdfExporter:
         best_layout = (0, 0, False)
 
         for rotated in [False, True]:
-            img_w, img_h = (
+            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) / (img_w + self.gap)
+                (page_width - 2 * self.margins[0] + self.gap) / (image_width + self.gap)
             )
             rows = int(
-                (page_height - 2 * self.margins[1] + self.gap) / (img_h + self.gap)
+                (page_height - 2 * self.margins[1] + self.gap)
+                / (image_height + self.gap)
             )
 
             if cols * rows > best_fit:
@@ -112,16 +114,16 @@ class PdfExporter:
             if cols == 0 or rows == 0:
                 raise ValueError("The images are too large to fit on the page.")
 
-            img_w, img_h = (
+            image_width, image_height = (
                 (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
+            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:
@@ -132,37 +134,37 @@ class PdfExporter:
                 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)
+                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),
-                        x,
-                        y,
-                        width=img_w,
-                        height=img_h,
+                        position_horizontal,
+                        position_vertical,
+                        width=image_width,
+                        height=image_height,
                         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)
+                    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),
-                        -img_h / 2,
-                        -img_w / 2,
-                        width=img_h,
-                        height=img_w,
+                        -image_height / 2,
+                        -image_width / 2,
+                        width=image_height,
+                        height=image_width,
                         preserveAspectRatio=True,
                     )
                     self.pdf.restoreState()
                 images_on_page += 1
 
             self.pdf.save()
-            logging.info("Successfully exported PDF to %s", self.output_path)
+            logger.info("Successfully exported PDF to %s", self.output_path)
         except Exception as e:
-            logging.error("An error occurred during PDF export: %s", e)
+            logger.error("An error occurred during PDF export: %s", e)
             raise

decksmith/gui/app.py

@@ -0,0 +1,341 @@
+"""
+This module contains the Flask application for the DeckSmith GUI.
+"""
+
+import io
+import json
+import os
+import signal
+import threading
+import time
+import webbrowser
+from io import StringIO
+from pathlib import Path
+from threading import Timer
+
+import pandas as pd
+from flask import (
+    Flask,
+    Response,
+    jsonify,
+    render_template,
+    request,
+    send_file,
+    stream_with_context,
+)
+from platformdirs import user_documents_dir
+from ruamel.yaml import YAML
+from waitress import serve
+
+from decksmith.card_builder import CardBuilder
+from decksmith.deck_builder import DeckBuilder
+from decksmith.export import PdfExporter
+from decksmith.logger import logger
+from decksmith.macro import MacroResolver
+from decksmith.project import ProjectManager
+
+app = Flask(__name__)
+
+shutdown_event = threading.Event()
+SHUTDOWN_REASON = "Server stopped."
+
+
+def signal_handler(sig, frame):  # pylint: disable=unused-argument
+    """Handles system signals (e.g., SIGINT)."""
+    global SHUTDOWN_REASON  # pylint: disable=global-statement
+    SHUTDOWN_REASON = "Server stopped by user (Ctrl+C)."
+    logger.info(SHUTDOWN_REASON)
+    shutdown_event.set()
+
+    def delayed_exit():
+        time.sleep(1)
+        os._exit(0)
+
+    threading.Thread(target=delayed_exit).start()
+
+
+signal.signal(signal.SIGINT, signal_handler)
+
+
+@app.route("/api/events")
+def events():
+    """Streams server events to the client."""
+
+    def stream():
+        while not shutdown_event.is_set():
+            time.sleep(0.5)
+            yield ": keepalive\n\n"
+
+        yield f"data: {json.dumps({'type': 'shutdown', 'reason': SHUTDOWN_REASON})}\n\n"
+
+    return Response(stream_with_context(stream()), mimetype="text/event-stream")
+
+
+# Configuration
+project_manager = ProjectManager()
+
+
+@app.route("/")
+def index():
+    """Renders the main page."""
+    return render_template("index.html")
+
+
+@app.route("/api/project/current", methods=["GET"])
+def get_current_project():
+    """Returns the current project path."""
+    working_dir = project_manager.get_working_dir()
+    return jsonify({"path": str(working_dir) if working_dir else None})
+
+
+@app.route("/api/system/default-path", methods=["GET"])
+def get_default_path():
+    """Returns the default project path."""
+    default_path = Path(user_documents_dir()) / "DeckSmith"
+    try:
+        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
+
+
+@app.route("/api/system/browse", methods=["POST"])
+def browse_folder():
+    """Opens a folder selection dialog."""
+    try:
+        import crossfiledialog  # pylint: disable=import-outside-toplevel
+
+        folder_path = crossfiledialog.choose_folder(
+            title="Select Project Folder",
+            start_dir=str(Path.home()),
+        )
+
+        if folder_path:
+            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
+    except Exception as e:
+        logger.error("Error browsing folder: %s", e)
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/project/select", methods=["POST"])
+def select_project():
+    """Selects a project directory."""
+    path_str = request.json.get("path")
+    if not path_str:
+        return jsonify({"error": "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
+
+    project_manager.set_working_dir(path)
+    return jsonify({"status": "success", "path": str(path)})
+
+
+@app.route("/api/project/close", methods=["POST"])
+def close_project():
+    """Closes the current project."""
+    project_manager.close_project()
+    return jsonify({"status": "success"})
+
+
+@app.route("/api/project/create", methods=["POST"])
+def create_project():
+    """Creates a new project."""
+    path_str = request.json.get("path")
+    if not path_str:
+        return jsonify({"error": "Path is required"}), 400
+
+    path = Path(path_str)
+
+    try:
+        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
+
+
+@app.route("/api/load", methods=["GET"])
+def load_files():
+    """Loads project files."""
+    data = project_manager.load_files()
+    return jsonify(data)
+
+
+@app.route("/api/save", methods=["POST"])
+def save_files():
+    """Saves project files."""
+    if project_manager.get_working_dir() is None:
+        return jsonify({"error": "No project selected"}), 400
+
+    data = request.json
+    yaml_content = data.get("yaml")
+    csv_content = data.get("csv")
+
+    try:
+        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
+
+
+@app.route("/api/cards", methods=["GET"])
+def list_cards():
+    """Lists cards in the project."""
+    working_dir = project_manager.get_working_dir()
+    if working_dir is None:
+        return jsonify([])
+
+    csv_path = working_dir / "deck.csv"
+    if not csv_path.exists():
+        return jsonify([])
+
+    try:
+        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)
+        return jsonify({"error": str(e)}), 400
+
+
+@app.route("/api/preview/<int:card_index>", methods=["POST"])
+def preview_card(card_index):
+    """Previews a specific card."""
+    working_dir = project_manager.get_working_dir()
+    # Allow preview even without project, but base_path will be None
+
+    data = request.json
+    yaml_content = data.get("yaml")
+    csv_content = data.get("csv")
+
+    try:
+        yaml = YAML()
+        spec = yaml.load(yaml_content)
+    except Exception as e:
+        return jsonify({"error": f"Invalid YAML: {e}"}), 400
+
+    try:
+        csv_table = pd.read_csv(StringIO(csv_content), sep=";")
+        if card_index < 0 or card_index >= len(csv_table):
+            return jsonify({"error": "Index out of bounds"}), 400
+        row = csv_table.iloc[card_index]
+    except Exception as e:
+        return jsonify({"error": f"Invalid CSV: {e}"}), 400
+
+    try:
+        row_dict = row.to_dict()
+        resolved_spec = MacroResolver.resolve(spec, row_dict)
+
+        builder = CardBuilder(resolved_spec, base_path=working_dir)
+        card_image = builder.render()
+
+        image_buffer = io.BytesIO()
+        card_image.save(image_buffer, "PNG")
+        image_buffer.seek(0)
+        return send_file(image_buffer, mimetype="image/png")
+
+    except Exception as e:
+        logger.error("Error previewing card: %s", e)
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/build", methods=["POST"])
+def build_deck():
+    """Builds the deck."""
+    working_dir = project_manager.get_working_dir()
+    if working_dir is None:
+        return jsonify({"error": "No project selected"}), 400
+
+    # Save current state first
+    data = request.json
+    yaml_content = data.get("yaml")
+    csv_content = data.get("csv")
+
+    try:
+        project_manager.save_files(yaml_content, csv_content)
+
+        yaml_path = working_dir / "deck.yaml"
+        csv_path = working_dir / "deck.csv"
+        output_path = working_dir / "output"
+        output_path.mkdir(exist_ok=True)
+
+        builder = DeckBuilder(yaml_path, csv_path)
+        builder.build_deck(output_path)
+
+        return jsonify({"status": "success", "message": f"Deck built in {output_path}"})
+    except Exception as e:
+        logger.error("Error building deck: %s", e)
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/export", methods=["POST"])
+def export_pdf():
+    """Exports the deck to PDF."""
+    working_dir = project_manager.get_working_dir()
+    if working_dir is None:
+        return jsonify({"error": "No project selected"}), 400
+
+    data = request.json or {}
+
+    try:
+        image_folder = working_dir / "output"
+
+        filename = data.get("filename", "deck.pdf")
+        if not filename.endswith(".pdf"):
+            filename += ".pdf"
+
+        output_pdf = working_dir / filename
+
+        if not image_folder.exists():
+            return jsonify(
+                {"error": "Output folder does not exist. Build deck first."}
+            ), 400
+
+        exporter = PdfExporter(
+            image_folder=image_folder,
+            output_path=output_pdf,
+            page_size_str=data.get("page_size", "A4"),
+            image_width=float(data.get("width", 63.5)),
+            image_height=float(data.get("height", 88.9)),
+            gap=float(data.get("gap", 0)),
+            margins=(float(data.get("margin_x", 2)), float(data.get("margin_y", 2))),
+        )
+        exporter.export()
+
+        return jsonify(
+            {"status": "success", "message": f"PDF exported to {output_pdf}"}
+        )
+    except Exception as e:
+        logger.error("Error exporting PDF: %s", e)
+        return jsonify({"error": str(e)}), 500
+
+
+def open_browser():
+    """Opens the browser."""
+    webbrowser.open_new("http://127.0.0.1:5000/")
+
+
+@app.route("/api/shutdown", methods=["POST"])
+def shutdown():
+    """Shuts down the server."""
+    logger.info("Shutdown signal received. Shutting down.")
+    os._exit(0)
+
+
+def main():
+    """Main entry point for the GUI."""
+    # Open browser after a short delay to ensure server is running
+    Timer(1, open_browser).start()
+
+    serve(app, host="127.0.0.1", port=5000)
+
+
+if __name__ == "__main__":
+    main()