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

decksmith/main.py

@@ -1,138 +1,146 @@
-"""
-This module provides a command-line tool for building decks of cards.
-"""
-
-import shutil
-from importlib import resources
-from pathlib import Path
-import traceback
-
-import click
-from decksmith.deck_builder import DeckBuilder
-from decksmith.export import PdfExporter
-
-
-@click.group()
-def cli():
-    """A command-line tool for building decks of cards."""
-
-
-@cli.command()
-def init():
-    """Initializes a new project by creating deck.json and deck.csv."""
-    if Path("deck.json").exists() or Path("deck.csv").exists():
-        click.echo("(!) Project already initialized.")
-        return
-
-    with resources.path("decksmith.templates", "deck.json") as template_path:
-        shutil.copy(template_path, "deck.json")
-    with resources.path("decksmith.templates", "deck.csv") as template_path:
-        shutil.copy(template_path, "deck.csv")
-
-    click.echo("(✔) Initialized new project from templates.")
-
-
-@cli.command(context_settings={"show_default": True})
-@click.option("--output", default="output", help="The output directory for the deck.")
-@click.option(
-    "--spec", default="deck.json", help="The path to the deck specification file."
-)
-@click.option("--data", default="deck.csv", help="The path to the data file.")
-@click.pass_context
-def build(ctx, output, spec, data):
-    """Builds the deck of cards."""
-    output_path = Path(output)
-    output_path.mkdir(exist_ok=True)
-
-    click.echo(f"(i) Building deck in {output_path}...")
-
-    try:
-        spec_path = Path(spec)
-        if not spec_path.exists():
-            raise FileNotFoundError(f"Spec file not found: {spec_path}")
-
-        csv_path = Path(data)
-        if not csv_path.exists():
-            source = ctx.get_parameter_source("data")
-            if source.name == "DEFAULT":
-                click.echo(
-                    f"(i) Building a single card deck because '{csv_path}' was not found"
-                )
-                csv_path = None
-            else:
-                raise FileNotFoundError(f"Data file not found: {csv_path}")
-
-        builder = DeckBuilder(spec_path, csv_path)
-        builder.build_deck(output_path)
-    except FileNotFoundError as exc:
-        click.echo(f"(x) {exc}")
-        ctx.exit(1)
-    # pylint: disable=W0718
-    except Exception as exc:
-        with open("log.txt", "a", encoding="utf-8") as log:
-            log.write(traceback.format_exc())
-        # print(f"{traceback.format_exc()}", end="\n")
-        print(f"(x) Error building deck '{data}' from spec '{spec}':")
-        print(" " * 4 + f"{exc}")
-        ctx.exit(1)
-
-    click.echo("(✔) Deck built successfully.")
-
-
-@cli.command(context_settings={"show_default": True})
-@click.argument("image_folder")
-@click.option(
-    "--output", default="output.pdf", help="The path for the output PDF file."
-)
-@click.option(
-    "--page-size", default="A4", help="The page size for the PDF (e.g., A4, Letter)."
-)
-@click.option(
-    "--width", type=float, default=63.5, help="The width for each image in millimeters."
-)
-@click.option(
-    "--height",
-    type=float,
-    default=88.9,
-    help="The height for each image in millimeters.",
-)
-@click.option(
-    "--gap", type=float, default=0, help="The gap between images in millimeters."
-)
-@click.option(
-    "--margins",
-    type=float,
-    nargs=2,
-    default=[2, 2],
-    help="The horizontal and vertical page margins in millimeters.",
-)
-def export(image_folder, output, page_size, width, height, gap, margins):
-    """Exports images from a folder to a PDF file."""
-    try:
-        image_folder_path = Path(image_folder)
-        if not image_folder_path.exists():
-            raise FileNotFoundError(f"Image folder not found: {image_folder_path}")
-
-        exporter = PdfExporter(
-            image_folder=image_folder_path,
-            output_path=Path(output),
-            page_size_str=page_size,
-            image_width=width,
-            image_height=height,
-            gap=gap,
-            margins=margins,
-        )
-        exporter.export()
-        click.echo(f"(✔) Successfully exported PDF to {output}")
-    except FileNotFoundError as exc:
-        click.echo(f"(x) {exc}")
-    # pylint: disable=W0718
-    except Exception as exc:
-        with open("log.txt", "a", encoding="utf-8") as log:
-            log.write(traceback.format_exc())
-        print(f"(x) Error exporting images to '{output}':")
-        print(" " * 4 + f"{exc}")
-
-
-if __name__ == "__main__":
-    cli()
+"""
+This module provides a command-line tool for building decks of cards.
+"""
+
+import shutil
+import traceback
+from importlib import resources
+from pathlib import Path
+
+import click
+
+from decksmith.deck_builder import DeckBuilder
+from decksmith.export import PdfExporter
+from decksmith.gui.app import main as gui_main
+from decksmith.logger import logger
+
+
+@click.group(invoke_without_command=True)
+@click.option("--gui", is_flag=True, help="Launch the graphical user interface.")
+@click.pass_context
+def cli(ctx, gui):
+    """A command-line tool for building decks of cards."""
+    if gui:
+        gui_main()
+    elif ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+
+
+@cli.command()
+def init():
+    """Initializes a new project by creating deck.yaml and deck.csv."""
+    if Path("deck.yaml").exists() or Path("deck.csv").exists():
+        click.echo("(!) Project already initialized.")
+        return
+
+    with resources.path("decksmith.templates", "deck.yaml") as template_path:
+        shutil.copy(template_path, "deck.yaml")
+    with resources.path("decksmith.templates", "deck.csv") as template_path:
+        shutil.copy(template_path, "deck.csv")
+
+    click.echo("(✔) Initialized new project from templates.")
+
+
+@cli.command(context_settings={"show_default": True})
+@click.option("--output", default="output", help="The output directory for the deck.")
+@click.option(
+    "--spec", default="deck.yaml", help="The path to the deck specification file."
+)
+@click.option("--data", default="deck.csv", help="The path to the data file.")
+@click.pass_context
+def build(ctx, output, spec, data):
+    """Builds the deck of cards."""
+    output_path = Path(output)
+    output_path.mkdir(exist_ok=True)
+
+    logger.info("(i) Building deck in %s...", output_path)
+
+    try:
+        spec_path = Path(spec)
+        if not spec_path.exists():
+            raise FileNotFoundError(f"Spec file not found: {spec_path}")
+
+        csv_path = Path(data)
+        if not csv_path.exists():
+            source = ctx.get_parameter_source("data")
+            if source.name == "DEFAULT":
+                logger.info(
+                    "(i) Building a single card deck because '%s' was not found",
+                    csv_path,
+                )
+                csv_path = None
+            else:
+                raise FileNotFoundError(f"Data file not found: {csv_path}")
+
+        builder = DeckBuilder(spec_path, csv_path)
+        builder.build_deck(output_path)
+    except FileNotFoundError as exc:
+        click.echo(f"(x) {exc}")
+        ctx.exit(1)
+    # pylint: disable=W0718
+    except Exception as exc:
+        logger.error("(x) Error building deck '%s' from spec '%s':", data, spec)
+        logger.error("    %s", exc)
+        logger.debug(traceback.format_exc())
+        ctx.exit(1)
+
+    logger.info("(✔) Deck built successfully.")
+
+
+@cli.command(context_settings={"show_default": True})
+@click.argument("image_folder")
+@click.option(
+    "--output", default="output.pdf", help="The path for the output PDF file."
+)
+@click.option(
+    "--page-size", default="A4", help="The page size for the PDF (e.g., A4, Letter)."
+)
+@click.option(
+    "--width", type=float, default=63.5, help="The width for each image in millimeters."
+)
+@click.option(
+    "--height",
+    type=float,
+    default=88.9,
+    help="The height for each image in millimeters.",
+)
+@click.option(
+    "--gap", type=float, default=0, help="The gap between images in millimeters."
+)
+@click.option(
+    "--margins",
+    type=float,
+    nargs=2,
+    default=[2, 2],
+    help="The horizontal and vertical page margins in millimeters.",
+)
+def export(image_folder, output, page_size, width, height, gap, margins):
+    """Exports images from a folder to a PDF file."""
+    try:
+        image_folder_path = Path(image_folder)
+        if not image_folder_path.exists():
+            raise FileNotFoundError(f"Image folder not found: {image_folder_path}")
+
+        exporter = PdfExporter(
+            image_folder=image_folder_path,
+            output_path=Path(output),
+            page_size_str=page_size,
+            image_width=width,
+            image_height=height,
+            gap=gap,
+            margins=margins,
+        )
+        exporter.export()
+        logger.info("(✔) Successfully exported PDF to %s", output)
+    except FileNotFoundError as exc:
+        logger.error("(x) %s", exc)
+    # pylint: disable=W0718
+    except Exception as exc:
+        logger.error("(x) Error exporting images to '%s':", output)
+        logger.error("    %s", exc)
+        logger.debug(traceback.format_exc())
+
+
+if __name__ == "__main__":
+    # pylint: disable=no-value-for-parameter
+    cli()

decksmith/project.py

@@ -0,0 +1,111 @@
+"""
+This module contains the ProjectManager class for managing decksmith projects.
+"""
+
+import shutil
+from pathlib import Path
+from typing import Dict, Optional
+
+
+class ProjectManager:
+    """
+    A class to manage decksmith projects.
+    """
+
+    def __init__(self):
+        self.working_dir: Optional[Path] = None
+
+    def set_working_dir(self, path: Path):
+        """Sets the working directory."""
+        self.working_dir = path
+
+    def get_working_dir(self) -> Optional[Path]:
+        """Returns the current working directory."""
+        return self.working_dir
+
+    def close_project(self):
+        """Closes the current project."""
+        self.working_dir = None
+
+    def create_project(self, path: Path):
+        """
+        Creates a new project at the specified path.
+        Args:
+            path (Path): The path to create the project in.
+        """
+        path.mkdir(parents=True, exist_ok=True)
+
+        # Copy templates
+        # Assuming templates are in decksmith/templates relative to this file
+        # But actually they are in decksmith/templates relative to the package root
+        # Let's use importlib.resources or relative path from __file__
+        # Since we are in decksmith/project.py, templates are in ../templates
+        template_dir = Path(__file__).parent / "templates"
+
+        if not (path / "deck.yaml").exists():
+            shutil.copy(template_dir / "deck.yaml", path / "deck.yaml")
+
+        if not (path / "deck.csv").exists():
+            shutil.copy(template_dir / "deck.csv", path / "deck.csv")
+
+        self.working_dir = path
+
+    def load_files(self) -> Dict[str, str]:
+        """
+        Loads the deck.yaml and deck.csv files from the current project.
+        Returns:
+            Dict[str, str]: A dictionary containing the content of the files.
+        """
+        if self.working_dir is None:
+            return {"yaml": "", "csv": ""}
+
+        yaml_path = self.working_dir / "deck.yaml"
+        csv_path = self.working_dir / "deck.csv"
+
+        template_dir = Path(__file__).parent / "templates"
+        yaml_template = template_dir / "deck.yaml"
+        csv_template = template_dir / "deck.csv"
+
+        data = {}
+
+        # Load YAML
+        if yaml_path.exists() and yaml_path.stat().st_size > 0:
+            with open(yaml_path, "r", encoding="utf-8") as yaml_file:
+                data["yaml"] = yaml_file.read()
+        elif yaml_template.exists():
+            with open(yaml_template, "r", encoding="utf-8") as yaml_template_file:
+                data["yaml"] = yaml_template_file.read()
+        else:
+            data["yaml"] = ""
+
+        # Load CSV
+        if csv_path.exists() and csv_path.stat().st_size > 0:
+            with open(csv_path, "r", encoding="utf-8") as csv_file:
+                data["csv"] = csv_file.read()
+        elif csv_template.exists():
+            with open(csv_template, "r", encoding="utf-8") as csv_template_file:
+                data["csv"] = csv_template_file.read()
+        else:
+            data["csv"] = ""
+
+        return data
+
+    def save_files(self, yaml_content: Optional[str], csv_content: Optional[str]):
+        """
+        Saves the deck.yaml and deck.csv files to the current project.
+        Args:
+            yaml_content (Optional[str]): The content of the deck.yaml file.
+            csv_content (Optional[str]): The content of the deck.csv file.
+        """
+        if self.working_dir is None:
+            raise ValueError("No project selected")
+
+        if yaml_content is not None:
+            with open(
+                self.working_dir / "deck.yaml", "w", encoding="utf-8"
+            ) as yaml_file:
+                yaml_file.write(yaml_content.replace("\r\n", "\n"))
+
+        if csv_content is not None:
+            with open(self.working_dir / "deck.csv", "w", encoding="utf-8") as csv_file:
+                csv_file.write(csv_content.replace("\r\n", "\n"))

decksmith/renderers/__init__.py

@@ -0,0 +1,3 @@
+"""
+This package contains renderer classes for different card elements.
+"""

decksmith/renderers/image.py

@@ -0,0 +1,76 @@
+"""
+This module contains the ImageRenderer class for drawing images on cards.
+"""
+
+import operator
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from PIL import Image
+
+from decksmith.image_ops import ImageOps
+from decksmith.logger import logger
+from decksmith.utils import apply_anchor
+
+
+class ImageRenderer:
+    """
+    A class to render image elements on a card.
+    """
+
+    def __init__(self, base_path: Optional[Path] = None):
+        self.base_path = base_path
+
+    def render(
+        self,
+        card: Image.Image,
+        element: Dict[str, Any],
+        calculate_pos_func,
+        store_pos_func,
+    ):
+        """
+        Draws an image on the card.
+        Args:
+            card (Image.Image): The card image object.
+            element (Dict[str, Any]): The image element specification.
+            calculate_pos_func (callable): Function to calculate absolute position.
+            store_pos_func (callable): Function to store element position.
+        """
+        assert element.pop("type") == "image", "Element type must be 'image'"
+
+        path_str = element["path"]
+        path = Path(path_str)
+
+        if not path.is_absolute() and self.base_path:
+            potential_path = self.base_path / path
+            if potential_path.exists():
+                path = potential_path
+
+        try:
+            img = Image.open(path)
+        except FileNotFoundError:
+            logger.error("Image not found: %s", path)
+            return
+
+        img = ImageOps.apply_filters(img, element.get("filters", {}))
+
+        position = calculate_pos_func(element)
+        if "anchor" in element:
+            anchor_point = apply_anchor((img.width, img.height), element.pop("anchor"))
+            position = tuple(map(operator.sub, position, anchor_point))
+
+        if img.mode == "RGBA":
+            card.paste(img, position, mask=img)
+        else:
+            card.paste(img, position)
+
+        if "id" in element:
+            store_pos_func(
+                element["id"],
+                (
+                    position[0],
+                    position[1],
+                    position[0] + img.width,
+                    position[1] + img.height,
+                ),
+            )