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

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

@@ -43,24 +43,30 @@ def apply_anchor(size: Tuple[int, ...], anchor: str) -> Tuple[int, int]:
         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
+        width, height = size
+        position_horizontal, position_vertical = 0, 0
     elif len(size) == 4:
-        x, y, x2, y2 = size
-        w, h = x2 - x, y2 - y
+        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": (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),
+        "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:

decksmith/validate.py

@@ -2,7 +2,7 @@
 This module provides functions for validating and transforming card specifications.
 """
 
-from typing import Dict, Any
+from typing import Any, Dict
 
 import pandas as pd
 from jval import validate

{decksmith-0.1.14.dist-info → decksmith-0.9.1.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: decksmith
-Version: 0.1.14
-Summary: A command-line application to dynamically generate decks of cards from a JSON specification and a CSV data file, inspired by nandeck.
+Version: 0.9.1
+Summary: A command-line application to dynamically generate decks of cards from a YAML specification and a CSV data file, inspired by nandeck.
 License-Expression: GPL-2.0-only
 Author: Julio Cabria
 Author-email: juliocabria@tutanota.com
@@ -13,27 +13,26 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: dev
 Requires-Dist: click
+Requires-Dist: crossfiledialog (>=1.1.0)
+Requires-Dist: flask (>=3.1.2)
 Requires-Dist: jval (==1.0.6)
 Requires-Dist: pandas
 Requires-Dist: pillow (>=11.3.0)
-Requires-Dist: poetry ; extra == "dev"
+Requires-Dist: platformdirs (>=4.5.1)
 Requires-Dist: pytest ; extra == "dev"
+Requires-Dist: pywin32 (>=311) ; sys_platform == "win32"
 Requires-Dist: reportlab (>=4.4.3)
-Project-URL: Homepage, https://github.com/Julynx/decksmith
+Requires-Dist: ruamel-yaml (>=0.19.1)
+Requires-Dist: waitress (>=3.0.2)
 Description-Content-Type: text/markdown
 
 # DeckSmith
 
-*A command-line application to dynamically generate decks of cards from a JSON specification and a CSV data file, inspired by nandeck.*
+*A powerful application to dynamically generate decks of cards from a YAML specification and a CSV data file.*
 
 <br>
 <p align="center">
-  <img width="600" src="https://raw.githubusercontent.com/Julynx/decksmith/refs/heads/main/docs/assets/decksmith.png">
-</p>
-
-<br>
-<p align="center">
-  <img width="600" src="https://raw.githubusercontent.com/Julynx/decksmith/refs/heads/main/docs/assets/banner.png">
+  <img src="https://raw.githubusercontent.com/Julynx/decksmith/refs/heads/main/docs/assets/screenshot.png" width='100%'>
 </p>
 
 <br>
@@ -44,29 +43,64 @@ DeckSmith is ideal for automating the creation of all kinds of decks, including
 
 - ✨ Consistent layout and formatting across all cards. Define once, edit anytime, generate as many cards as you need.
 - 🍳 Pure python, with easy installation via pip.
+- 🖥️ User-friendly GUI for easy project management and generation.
 - ⚡ Highly performant card generation using parallel processing.
-- 📖 Intuitive syntax and extensive [documentation](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md) with examples to help you get started quickly.
+- 📖 Intuitive syntax and extensive [documentation](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md) with examples to help you get started.
 - 🧰 Tons of powerful features such as:
   - [Start from a sample project and edit it instead of starting from scratch](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md#creating-a-project)
   - [Extensive support for images](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md#images), [text](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md#text), [and all kinds of different shapes](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md#shapes)
-  - [Link any field to a column in the CSV file](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md#basic-example-with-deckcsv)
+  - [Link any field to a column in the CSV file](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md#example-with-deckcsv)
   - [Position elements absolutely or relative to other elements, using anchors to simplify placement](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md#positioning)
   - [Powerful image transformations using filters like crop, resize, rotate, or flip](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md#images)
   - [Export your deck as images or as a PDF for printing](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md#building-the-deck)
 
 ## Getting started
 
-- First, install DeckSmith by running `pip install decksmith`.
+### Installation
+
+- To begin, install DeckSmith by running:
+
+  ```bash
+  pip install decksmith
+  ```
+
+- To launch the GUI, run:
+
+  ```bash
+  decksmith --gui
+  ```
+
+### Creating a project
+
+- Run the following command to start from sample `deck.yaml` and `deck.csv` files:
+
+  ```text
+  decksmith init
+  ```
+
+  - `deck.yaml` defines the layout for the cards in the deck.
+  - `deck.csv` holds the data for each card, like the content of the text fields and the image paths.
+
+### Defining the layout
+
+- Edit `deck.yaml` to include all the elements you want on your cards.
+  You can find a complete list of all the available elements and their properties in the [documentation](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md).
+
+- You can reference any column from `deck.csv` in the `deck.yaml` file as `%column_name%`.
 
-- Then, run `decksmith init` to start from sample `deck.json` and `deck.csv` files.
+### Building the deck
 
-- The `deck.json` file defines the layout for the cards in the deck, while the `deck.csv` file holds the data for each card.
+- When you are ready to generate the deck images, run:
 
-  - You can find a complete list of all the available elements you can use in the [documentation](https://github.com/Julynx/decksmith/blob/main/docs/DOCS.md).
+  ```text
+  decksmith build
+  ```
 
-  - Any column from the CSV can be referenced anywhere in the JSON as `%column_name%`.
+- After building a deck, you can export it to PDF by running:
 
-- Finally, run `decksmith build` when you are ready to generate the deck images, and export them to PDF using the `decksmith export` command.
+  ```text
+  decksmith export
+  ```
 
 ## Documentation
 

decksmith-0.9.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+decksmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+decksmith/card_builder.py,sha256=hxDVS7-dngCiT392pP2aiWgasfSp1ou3v3lzWmLXxL4,5618
+decksmith/deck_builder.py,sha256=J_Zdj4m-tXPSZh67mEyOCQ_CTphRCsPiyHSh1HcNM0M,3305
+decksmith/export.py,sha256=rzRGdyfK1YXu_k9cpkXvNFZZBkpfXW5zPr_iotlJxcY,5979
+decksmith/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+decksmith/gui/app.py,sha256=NQPR_hfCVvrr0QnEUmJXQv_A4lFXXoF8_OostVLwZkU,10178
+decksmith/gui/static/css/style.css,sha256=djBsKvc7tm7VaK5PWm1vFtan_PyEWESWjckgNSevr2s,13582
+decksmith/gui/static/js/main.js,sha256=A1Vz4kxlokqTadESYT7PlZf4XkVlaT0AXmSNNSrmixw,21680
+decksmith/gui/templates/index.html,sha256=xQhMFPzkCo1F6qR48NHjLkk12wzgn0Hh0LXTA4ShueE,8949
+decksmith/image_ops.py,sha256=8UzibqfoED_Jch-lt--l2LIAoIwdBrXH7so5UqY5pqw,4737
+decksmith/logger.py,sha256=uSMzIpv7xT7ICMz4a88x_Z9-Izz0WU9MdZ9JEwWnOC4,1020
+decksmith/macro.py,sha256=prHs0fTIqxE5kjT1usqnWg8CNZEoWUVNAezD-qJslRY,1584
+decksmith/main.py,sha256=Jm98JBo3a2H_S7mwHEWg8NzyUBXdbFewFxzlpPxjDLI,4653
+decksmith/project.py,sha256=QbhSOAveCuQ05P2Dp-uIc7hkC_o0-NAq3LIWQ4g-FnU,3885
+decksmith/renderers/__init__.py,sha256=xF0SsNJSQEbY-NoSN0N4admLTGc_4JcZumDMpQahWBM,76
+decksmith/renderers/image.py,sha256=SKj_21wlAjHGEG6M0GGu4OkwmJrxf0Nnk9TCu_2BP38,2218
+decksmith/renderers/shapes.py,sha256=iSCCr4hn2lj4EGchq324_eHtuuYAhemYP9PSEUFBkxM,7855
+decksmith/renderers/text.py,sha256=rN3vYUPWy_OpbxiGI5nydOu2V4O1CnoVKaqRIv64waU,4465
+decksmith/templates/deck.csv,sha256=8P3XknSg6kXulNyAmqFHgJDIzGjMnvdMQ8ctTtUoIzE,782
+decksmith/templates/deck.yaml,sha256=3BMpTUH1It25wrmQXZSrERoPo4-8TBKXKxfaRtYowt8,1034
+decksmith/utils.py,sha256=-QHYbNKQeB1SXB5Ovswn6Yql9sfSb5CmSNVpsw3LiVM,2909
+decksmith/validate.py,sha256=uNkBg0ruZp63gOu687Ed2hrtepV9Ez6NwnikKfvexzs,3813
+decksmith-0.9.1.dist-info/entry_points.txt,sha256=-usRztjj2gnfmPubb8nFYHD22drzThAmSfM6geWI98Y,48
+decksmith-0.9.1.dist-info/METADATA,sha256=u3WtryzgPYzisJIQ-gjvL4NaxmeTmM6uUKMeqUx7HZA,4249
+decksmith-0.9.1.dist-info/WHEEL,sha256=kJCRJT_g0adfAJzTx2GUMmS80rTJIVHRCfG0DQgLq3o,88
+decksmith-0.9.1.dist-info/RECORD,,

{decksmith-0.1.14.dist-info → decksmith-0.9.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.2.1
+Generator: poetry-core 2.3.1
 Root-Is-Purelib: true
 Tag: py3-none-any

decksmith/templates/deck.json

@@ -1,31 +0,0 @@
-{
-  "width": 250,
-  "height": 350,
-  "background_color": [200, 200, 200],
-  "elements": [
-    {
-      "id": "title",
-      "type": "text",
-      "position": [125, 25],
-      "anchor": "top-center",
-      "text": "%title%",
-      "color": [0, 0, 0],
-      "font_path": "arial.ttf",
-      "font_size": 20,
-      "align": "center"
-    },
-    {
-      "id": "description",
-      "type": "text",
-      "position": [0, 25],
-      "relative_to": ["title", "bottom-center"],
-      "anchor": "top-center",
-      "text": "%description%",
-      "color": [0, 0, 0],
-      "font_path": "arial.ttf",
-      "font_size": 16,
-      "width": 200,
-      "align": "center"
-    }
-  ]
-}