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

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,
+                ),
+            )

decksmith/renderers/shapes.py

@@ -0,0 +1,237 @@
+"""
+This module contains the ShapeRenderer class for drawing shapes on cards.
+"""
+
+import operator
+from typing import Any, Dict
+
+from PIL import Image, ImageDraw
+
+from decksmith.utils import apply_anchor
+
+
+class ShapeRenderer:
+    """
+    A class to render shape elements on a card.
+    """
+
+    def render(
+        self,
+        card: Image.Image,
+        element: Dict[str, Any],
+        calculate_pos_func,
+        store_pos_func,
+    ) -> Image.Image:
+        """
+        Draws a shape on the card.
+        Args:
+            card (Image.Image): The card image object.
+            element (Dict[str, Any]): The shape element specification.
+            calculate_pos_func (callable): Function to calculate absolute position.
+            store_pos_func (callable): Function to store element position.
+        Returns:
+            Image.Image: The updated card image.
+        """
+        element_type = element.get("type")
+        draw_methods = {
+            "circle": self._draw_shape_circle,
+            "ellipse": self._draw_shape_ellipse,
+            "polygon": self._draw_shape_polygon,
+            "regular-polygon": self._draw_shape_regular_polygon,
+            "rectangle": self._draw_shape_rectangle,
+        }
+
+        if draw_method := draw_methods.get(element_type):
+            return draw_method(card, element, calculate_pos_func, store_pos_func)
+        return card
+
+    def _draw_shape_generic(
+        self,
+        card: Image.Image,
+        element: Dict[str, Any],
+        draw_func,
+        size_func,
+        calculate_pos_func,
+        store_pos_func,
+    ) -> Image.Image:
+        """Generic method to draw shapes."""
+        size = size_func(element)
+        absolute_pos = calculate_pos_func(element)
+
+        if "color" in element:
+            element["fill"] = tuple(element["color"])
+        if "outline_color" in element:
+            element["outline_color"] = tuple(element["outline_color"])
+
+        if "anchor" in element:
+            anchor_offset = apply_anchor(size, element.pop("anchor"))
+            absolute_pos = tuple(map(operator.sub, absolute_pos, anchor_offset))
+
+        layer = Image.new("RGBA", card.size, (0, 0, 0, 0))
+        layer_draw = ImageDraw.Draw(layer, "RGBA")
+
+        draw_func(layer_draw, absolute_pos, element)
+
+        card = Image.alpha_composite(card, layer)
+
+        if "id" in element:
+            store_pos_func(
+                element["id"],
+                (
+                    absolute_pos[0],
+                    absolute_pos[1],
+                    absolute_pos[0] + size[0],
+                    absolute_pos[1] + size[1],
+                ),
+            )
+        return card
+
+    def _draw_shape_circle(
+        self,
+        card: Image.Image,
+        element: Dict[str, Any],
+        calculate_pos_func,
+        store_pos_func,
+    ) -> Image.Image:
+        assert element.pop("type") == "circle", "Element type must be 'circle'"
+        radius = element["radius"]
+
+        def draw(layer_draw, pos, element):
+            center_pos = (pos[0] + radius, pos[1] + radius)
+            layer_draw.circle(
+                center_pos,
+                radius,
+                fill=element.get("fill", None),
+                outline=element.get("outline_color", None),
+                width=element.get("outline_width", 1),
+            )
+
+        return self._draw_shape_generic(
+            card,
+            element,
+            draw,
+            lambda _: (radius * 2, radius * 2),
+            calculate_pos_func,
+            store_pos_func,
+        )
+
+    def _draw_shape_ellipse(
+        self,
+        card: Image.Image,
+        element: Dict[str, Any],
+        calculate_pos_func,
+        store_pos_func,
+    ) -> Image.Image:
+        assert element.pop("type") == "ellipse", "Element type must be 'ellipse'"
+        size = element["size"]
+
+        def draw(layer_draw, pos, element):
+            bbox = (pos[0], pos[1], pos[0] + size[0], pos[1] + size[1])
+            layer_draw.ellipse(
+                bbox,
+                fill=element.get("fill", None),
+                outline=element.get("outline_color", None),
+                width=element.get("outline_width", 1),
+            )
+
+        return self._draw_shape_generic(
+            card, element, draw, lambda _: size, calculate_pos_func, store_pos_func
+        )
+
+    def _draw_shape_polygon(
+        self,
+        card: Image.Image,
+        element: Dict[str, Any],
+        calculate_pos_func,
+        store_pos_func,
+    ) -> Image.Image:
+        assert element.pop("type") == "polygon", "Element type must be 'polygon'"
+        points = [tuple(point) for point in element.get("points", [])]
+        if not points:
+            return card
+
+        min_horizontal = min(point[0] for point in points)
+        max_horizontal = max(point[0] for point in points)
+        min_vertical = min(point[1] for point in points)
+        max_vertical = max(point[1] for point in points)
+        bbox_size = (max_horizontal - min_horizontal, max_vertical - min_vertical)
+
+        def draw(layer_draw, pos, element):
+            # pos is the top-left of the bounding box
+            # We need to shift points so that (min_horizontal, min_vertical) aligns with pos
+            offset_horizontal = pos[0] - min_horizontal
+            offset_vertical = pos[1] - min_vertical
+            final_points = [
+                (point[0] + offset_horizontal, point[1] + offset_vertical)
+                for point in points
+            ]
+
+            layer_draw.polygon(
+                final_points,
+                fill=element.get("fill", None),
+                outline=element.get("outline_color", None),
+                width=element.get("outline_width", 1),
+            )
+
+        return self._draw_shape_generic(
+            card, element, draw, lambda _: bbox_size, calculate_pos_func, store_pos_func
+        )
+
+    def _draw_shape_regular_polygon(
+        self,
+        card: Image.Image,
+        element: Dict[str, Any],
+        calculate_pos_func,
+        store_pos_func,
+    ) -> Image.Image:
+        assert element.pop("type") == "regular-polygon", (
+            "Element type must be 'regular-polygon'"
+        )
+        radius = element["radius"]
+
+        def draw(layer_draw, pos, element):
+            center_pos = (pos[0] + radius, pos[1] + radius)
+            layer_draw.regular_polygon(
+                (center_pos[0], center_pos[1], radius),
+                n_sides=element["sides"],
+                rotation=element.get("rotation", 0),
+                fill=element.get("fill", None),
+                outline=element.get("outline_color", None),
+                width=element.get("outline_width", 1),
+            )
+
+        return self._draw_shape_generic(
+            card,
+            element,
+            draw,
+            lambda _: (radius * 2, radius * 2),
+            calculate_pos_func,
+            store_pos_func,
+        )
+
+    def _draw_shape_rectangle(
+        self,
+        card: Image.Image,
+        element: Dict[str, Any],
+        calculate_pos_func,
+        store_pos_func,
+    ) -> Image.Image:
+        assert element.pop("type") == "rectangle", "Element type must be 'rectangle'"
+        size = element["size"]
+        if "corners" in element:
+            element["corners"] = tuple(element["corners"])
+
+        def draw(layer_draw, pos, element):
+            bbox = (pos[0], pos[1], pos[0] + size[0], pos[1] + size[1])
+            layer_draw.rounded_rectangle(
+                bbox,
+                radius=element.get("corner_radius", 0),
+                fill=element.get("fill", None),
+                outline=element.get("outline_color", None),
+                width=element.get("outline_width", 1),
+                corners=element.get("corners", None),
+            )
+
+        return self._draw_shape_generic(
+            card, element, draw, lambda _: size, calculate_pos_func, store_pos_func
+        )

decksmith/renderers/text.py

@@ -0,0 +1,127 @@
+"""
+This module contains the TextRenderer class for drawing text on cards.
+"""
+
+import operator
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import pandas as pd
+from PIL import ImageDraw, ImageFont
+
+from decksmith.logger import logger
+from decksmith.utils import apply_anchor, get_wrapped_text
+
+
+class TextRenderer:
+    """
+    A class to render text elements on a card.
+    """
+
+    def __init__(self, base_path: Optional[Path] = None):
+        self.base_path = base_path
+
+    def render(
+        self,
+        draw: ImageDraw.ImageDraw,
+        element: Dict[str, Any],
+        calculate_pos_func,
+        store_pos_func,
+    ):
+        """
+        Draws text on the card.
+        Args:
+            draw (ImageDraw.ImageDraw): The PIL ImageDraw object.
+            element (Dict[str, Any]): The text element specification.
+            calculate_pos_func (callable): Function to calculate absolute position.
+            store_pos_func (callable): Function to store element position.
+        """
+        assert element.pop("type") == "text", "Element type must be 'text'"
+
+        element = self._prepare_text_element(element)
+
+        original_pos = calculate_pos_func(element)
+        element["position"] = original_pos
+
+        # Calculate anchor offset if needed
+        if "anchor" in element:
+            bbox = draw.textbbox(
+                xy=(0, 0),
+                text=element.get("text"),
+                font=element["font"],
+                spacing=element.get("line_spacing", 4),
+                align=element.get("align", "left"),
+            )
+            anchor_point = apply_anchor(bbox, element.pop("anchor"))
+            element["position"] = tuple(map(operator.sub, original_pos, anchor_point))
+
+        # Draw text
+        draw.text(
+            xy=element.get("position"),
+            text=element.get("text"),
+            fill=element.get("color", None),
+            font=element["font"],
+            spacing=element.get("line_spacing", 4),
+            align=element.get("align", "left"),
+            stroke_width=element.get("stroke_width", 0),
+            stroke_fill=element.get("stroke_color", None),
+        )
+
+        # Store position
+        if "id" in element:
+            bbox = draw.textbbox(
+                xy=element.get("position"),
+                text=element.get("text"),
+                font=element["font"],
+                spacing=element.get("line_spacing", 4),
+                align=element.get("align", "left"),
+            )
+            store_pos_func(element["id"], bbox)
+
+    def _prepare_text_element(self, element: Dict[str, Any]) -> Dict[str, Any]:
+        """Prepares text element properties."""
+        if pd.isna(element["text"]):
+            element["text"] = " "
+
+        # Font setup
+        font_size = element.pop("font_size", 10)
+        if font_path := element.pop("font_path", False):
+            # Resolve font path relative to base_path if provided
+            if self.base_path and not Path(font_path).is_absolute():
+                potential_path = self.base_path / font_path
+                if potential_path.exists():
+                    font_path = str(potential_path)
+
+            try:
+                element["font"] = ImageFont.truetype(
+                    font_path, font_size, encoding="unic"
+                )
+            except OSError:
+                logger.error("Could not load font: %s. Using default.", font_path)
+                element["font"] = ImageFont.load_default(font_size)
+        else:
+            element["font"] = ImageFont.load_default(font_size)
+
+        if font_variant := element.pop("font_variant", None):
+            try:
+                element["font"].set_variation_by_name(font_variant)
+            except AttributeError:
+                logger.warning(
+                    "Font variant '%s' not supported for this font.", font_variant
+                )
+
+        # Text wrapping
+        if line_length := element.pop("width", False):
+            element["text"] = get_wrapped_text(
+                element["text"], element["font"], line_length
+            )
+
+        # Colors and position
+        if position := element.pop("position", [0, 0]):
+            element["position"] = tuple(position)
+        if color := element.pop("color", [0, 0, 0]):
+            element["color"] = tuple(color)
+        if stroke_color := element.pop("stroke_color", None):
+            element["stroke_color"] = tuple(stroke_color)
+
+        return element

decksmith/templates/deck.csv

@@ -1,5 +1,4 @@
-title;description
-Welcome to DeckSmith!;To get started, edit "deck.csv" to add new cards, or "deck.json" to change their structure.
-Building the deck;Run "decksmith build" when you are ready to save the cards as images.
-Exporting to PDF;You can create a printable PDF with "decksmith export --width 63.5 --height 88.9 output" after building.
-Check out the guide;Visit "github.com/julynx/decksmith" to learn all the things you can do using DeckSmith. Enjoy!
+title;first-paragraph;second-paragraph
+Welcome to DeckSmith!;This is a card. You can add as many cards as you need to your deck by adding a new line to the data file (CSV).;The layout file is a YAML file that holds the structure for all the cards in the deck.
+Connecting the dots;Any column in the data file (CSV) can be referenced from the layout file as "%colname%".;Cards can have all kinds of elements, such as images or shapes, that are layered in the order they appear in the layout file.
+Check out the docs;Shapes can have transparency, images can be transformed using filters, and elements can be placed relative to each other. You can also use custom fonts and much, much more!;Visit julynx.github.io/decksmith/docs.html to discover all you can do with DeckSmith. Enjoy!

decksmith/templates/deck.yaml

@@ -0,0 +1,46 @@
+id: canvas
+width: 1000
+height: 1400
+background_color: [220, 220, 220]
+elements:
+  - id: title
+    type: text
+    position: [0, 120]
+    relative_to: [canvas, top-center]
+    anchor: top-center
+    text: "%title%"
+    color: [50, 50, 100]
+    font_path: arial.ttf
+    font_size: 64
+    align: center
+  - id: line
+    type: rectangle
+    size: [600, 2]
+    position: [0, 100]
+    relative_to: [title, bottom-center]
+    anchor: top-center
+    color: [100, 100, 100]
+  - id: first-paragraph
+    type: text
+    position: [0, 200]
+    relative_to: [title, bottom-center]
+    anchor: top-center
+    text: "%first-paragraph%"
+    color: [50, 100, 100]
+    font_path: arial.ttf
+    font_size: 48
+    line_spacing: 20
+    width: 800
+    align: justify
+  - id: second-paragraph
+    type: text
+    position: [0, 100]
+    relative_to: [first-paragraph, bottom-center]
+    anchor: top-center
+    text: "%second-paragraph%"
+    color: [50, 100, 100]
+    font_path: arial.ttf
+    font_size: 48
+    line_spacing: 20
+    width: 800
+    align: justify

decksmith/utils.py

@@ -1,69 +1,75 @@
-"""
-This module provides utility functions for text wrapping and positioning.
-"""
-
-from typing import Tuple
-
-from PIL import ImageFont
-
-
-def get_wrapped_text(text: str, font: ImageFont.ImageFont, line_length: int) -> str:
-    """
-    Wraps text to fit within a specified line length using the given font,
-    preserving existing newlines.
-    Args:
-        text (str): The text to wrap.
-        font (ImageFont.ImageFont): The font to use for measuring text length.
-        line_length (int): The maximum length of each line in pixels.
-
-    Returns:
-        str: The wrapped text with newlines inserted where necessary.
-    """
-    wrapped_lines = []
-    for line in text.split("\n"):
-        lines = [""]
-        for word in line.split():
-            line_to_check = f"{lines[-1]} {word}".strip()
-            if font.getlength(line_to_check) <= line_length:
-                lines[-1] = line_to_check
-            else:
-                lines.append(word)
-        wrapped_lines.extend(lines)
-    return "\n".join(wrapped_lines)
-
-
-def apply_anchor(size: Tuple[int, ...], anchor: str) -> Tuple[int, int]:
-    """
-    Applies an anchor to a size tuple to determine the position of an element.
-    Args:
-        size (Tuple[int, ...]): A tuple representing the size (width, height)
-            or a bounding box (x1, y1, x2, y2).
-        anchor (str): The anchor position, e.g., "center", "top-left".
-    Returns:
-        Tuple[int, int]: A tuple representing the position (x, y) based on the anchor.
-    """
-    if len(size) == 2:
-        w, h = size
-        x, y = 0, 0
-    elif len(size) == 4:
-        x, y, x2, y2 = size
-        w, h = x2 - x, y2 - y
-    else:
-        raise ValueError("Size must be a tuple of 2 or 4 integers.")
-
-    anchor_points = {
-        "top-left": (x, y),
-        "top-center": (x + w // 2, y),
-        "top-right": (x + w, y),
-        "middle-left": (x, y + h // 2),
-        "center": (x + w // 2, y + h // 2),
-        "middle-right": (x + w, y + h // 2),
-        "bottom-left": (x, y + h),
-        "bottom-center": (x + w // 2, y + h),
-        "bottom-right": (x + w, y + h),
-    }
-
-    if anchor not in anchor_points:
-        raise ValueError(f"Unknown anchor: {anchor}")
-
-    return anchor_points[anchor]
+"""
+This module provides utility functions for text wrapping and positioning.
+"""
+
+from typing import Tuple
+
+from PIL import ImageFont
+
+
+def get_wrapped_text(text: str, font: ImageFont.ImageFont, line_length: int) -> str:
+    """
+    Wraps text to fit within a specified line length using the given font,
+    preserving existing newlines.
+    Args:
+        text (str): The text to wrap.
+        font (ImageFont.ImageFont): The font to use for measuring text length.
+        line_length (int): The maximum length of each line in pixels.
+
+    Returns:
+        str: The wrapped text with newlines inserted where necessary.
+    """
+    wrapped_lines = []
+    for line in text.split("\n"):
+        lines = [""]
+        for word in line.split():
+            line_to_check = f"{lines[-1]} {word}".strip()
+            if font.getlength(line_to_check) <= line_length:
+                lines[-1] = line_to_check
+            else:
+                lines.append(word)
+        wrapped_lines.extend(lines)
+    return "\n".join(wrapped_lines)
+
+
+def apply_anchor(size: Tuple[int, ...], anchor: str) -> Tuple[int, int]:
+    """
+    Applies an anchor to a size tuple to determine the position of an element.
+    Args:
+        size (Tuple[int, ...]): A tuple representing the size (width, height)
+            or a bounding box (x1, y1, x2, y2).
+        anchor (str): The anchor position, e.g., "center", "top-left".
+    Returns:
+        Tuple[int, int]: A tuple representing the position (x, y) based on the anchor.
+    """
+    if len(size) == 2:
+        width, height = size
+        position_horizontal, position_vertical = 0, 0
+    elif len(size) == 4:
+        position_horizontal, position_vertical, position_right, position_bottom = size
+        width, height = (
+            position_right - position_horizontal,
+            position_bottom - position_vertical,
+        )
+    else:
+        raise ValueError("Size must be a tuple of 2 or 4 integers.")
+
+    anchor_points = {
+        "top-left": (position_horizontal, position_vertical),
+        "top-center": (position_horizontal + width // 2, position_vertical),
+        "top-right": (position_horizontal + width, position_vertical),
+        "middle-left": (position_horizontal, position_vertical + height // 2),
+        "center": (
+            position_horizontal + width // 2,
+            position_vertical + height // 2,
+        ),
+        "middle-right": (position_horizontal + width, position_vertical + height // 2),
+        "bottom-left": (position_horizontal, position_vertical + height),
+        "bottom-center": (position_horizontal + width // 2, position_vertical + height),
+        "bottom-right": (position_horizontal + width, position_vertical + height),
+    }
+
+    if anchor not in anchor_points:
+        raise ValueError(f"Unknown anchor: {anchor}")
+
+    return anchor_points[anchor]