pydreamplet 0.1.0__tar.gz

pydreamplet-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marek Pilczuk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydreamplet-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.3
+Name: pydreamplet
+Version: 0.1.0
+Summary: A library for assembling SVGs from Python
+License: MIT
+Keywords: svg,graphics,design
+Author: Marek Pilczuk
+Author-email: user@mp76.pl
+Requires-Python: >=3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: fonttools (>=4.56.0,<5.0.0)
+Requires-Dist: ipython (>=8.32.0,<9.0.0)
+Requires-Dist: pillow (>=11.1.0,<12.0.0)
+Description-Content-Type: text/markdown
+
+# pyDreamplet
+
+low level library for SVG image generation. Perfect for data visualization with Python.
+
+## Installation
+
+Recommended using poetry
+
+```schell
+poetry add pydreamplet
+```
+
+## Usage example
+
+
+```python
+from pydreamplet import SVG, SvgElement
+from pydreamplet.colors import randomColor
+
+data = [130, 65, 108]
+
+def waffle_chart(data, side=100, rows=10, cols=10, gutter=2, colors=[]):
+    sorted_data = sorted(data, reverse=True)
+    while len(colors) < len(sorted_data):
+        colors.append(randomColor())
+
+    svg = SVG(dimensions=(side, side))
+    
+    total_cells = rows * cols
+    total = sum(data)
+    proportions = [int(round(d / total * total_cells, 0)) for d in sorted_data]
+    cell_side = (side - (cols + 1) * gutter) / cols
+    cell_group_map = []
+    for group_index, count in enumerate(proportions):
+        cell_group_map.extend([group_index] * count)
+    
+    if len(cell_group_map) < total_cells:
+        cell_group_map.extend([None] * (total_cells - len(cell_group_map)))
+    
+    paths = {i: "" for i in range(len(sorted_data))}
+    
+    for i in range(total_cells):
+        col = i % cols
+        row = i // cols
+        
+        x = gutter + col * (cell_side + gutter)
+        y = gutter + row * (cell_side + gutter)
+        
+        group = cell_group_map[i]
+        if group is not None:
+            paths[group] += f"M {x} {y} h {cell_side} v {cell_side} h -{cell_side} Z "
+    
+    for group_index, d_str in paths.items():
+        if d_str:
+            path = SvgElement("path", fill=colors[group_index], d=d_str)
+            svg.append(path)
+            
+    return svg
+
+
+svg = waffle_chart(data)
+svg.display()  # in jupyter notebook
+svg.save("waffle_chart.svg")
+```

pydreamplet-0.1.0/README.md

@@ -0,0 +1,64 @@
+# pyDreamplet
+
+low level library for SVG image generation. Perfect for data visualization with Python.
+
+## Installation
+
+Recommended using poetry
+
+```schell
+poetry add pydreamplet
+```
+
+## Usage example
+
+
+```python
+from pydreamplet import SVG, SvgElement
+from pydreamplet.colors import randomColor
+
+data = [130, 65, 108]
+
+def waffle_chart(data, side=100, rows=10, cols=10, gutter=2, colors=[]):
+    sorted_data = sorted(data, reverse=True)
+    while len(colors) < len(sorted_data):
+        colors.append(randomColor())
+
+    svg = SVG(dimensions=(side, side))
+    
+    total_cells = rows * cols
+    total = sum(data)
+    proportions = [int(round(d / total * total_cells, 0)) for d in sorted_data]
+    cell_side = (side - (cols + 1) * gutter) / cols
+    cell_group_map = []
+    for group_index, count in enumerate(proportions):
+        cell_group_map.extend([group_index] * count)
+    
+    if len(cell_group_map) < total_cells:
+        cell_group_map.extend([None] * (total_cells - len(cell_group_map)))
+    
+    paths = {i: "" for i in range(len(sorted_data))}
+    
+    for i in range(total_cells):
+        col = i % cols
+        row = i // cols
+        
+        x = gutter + col * (cell_side + gutter)
+        y = gutter + row * (cell_side + gutter)
+        
+        group = cell_group_map[i]
+        if group is not None:
+            paths[group] += f"M {x} {y} h {cell_side} v {cell_side} h -{cell_side} Z "
+    
+    for group_index, d_str in paths.items():
+        if d_str:
+            path = SvgElement("path", fill=colors[group_index], d=d_str)
+            svg.append(path)
+            
+    return svg
+
+
+svg = waffle_chart(data)
+svg.display()  # in jupyter notebook
+svg.save("waffle_chart.svg")
+```

pydreamplet-0.1.0/pydreamplet/__init__.py

@@ -0,0 +1,19 @@
+from pydreamplet.core import (
+    SVG,
+    Animate,
+    Circle,
+    Ellipse,
+    Rect,
+    SvgElement,
+    Text,
+)
+
+__all__ = [
+    "SVG",
+    "Animate",
+    "Circle",
+    "Ellipse",
+    "Rect",
+    "SvgElement",
+    "Text",
+]

pydreamplet-0.1.0/pydreamplet/colors.py

@@ -0,0 +1,115 @@
+import random
+import re
+
+from pydreamplet.utils import constrain, math_round
+
+
+def hexStr(n):
+    """
+    Converts an integer (0-255) to a two-digit hexadecimal string.
+    """
+    return format(n, "02x")
+
+
+def randomInt(min_val, max_val):
+    """Returns a random integer N such that min_val <= N <= max_val."""
+    return random.randint(min_val, max_val)
+
+
+def str2rgb(col):
+    """
+    Converts a hex color string to an RGB dictionary.
+    Accepts strings in the format "#RRGGBB" or "#RGB".
+    If the input doesn't match, returns {'r': 0, 'g': 0, 'b': 0}.
+    """
+    rgb = {"r": 0, "g": 0, "b": 0}
+    # Regex matches a string starting with one or more '#' and then either 6 or 3 hex digits.
+    rgx = re.compile(r"^#+([a-fA-F\d]{6}|[a-fA-F\d]{3})$")
+    if rgx.match(col):
+        # Expand shorthand (e.g. "#abc" -> "#aabbcc")
+        if len(col) == 4:
+            col = "#" + col[1] * 2 + col[2] * 2 + col[3] * 2
+        try:
+            rgb["r"] = int(col[1:3], 16)
+            rgb["g"] = int(col[3:5], 16)
+            rgb["b"] = int(col[5:7], 16)
+        except ValueError:
+            # In case of conversion error, keep default (0,0,0)
+            pass
+    return rgb
+
+
+def color2rgba(c, alpha=1):
+    """
+    Converts an input color (which can be a list/tuple of three numbers,
+    an integer, or a hex string) and an alpha value to an "rgba(r, g, b, a)" string.
+    """
+    r = g = b = 0
+    a = 1
+    if isinstance(c, (list, tuple)):
+        if len(c) == 3:
+            r = constrain(c[0], 0, 255)
+            g = constrain(c[1], 0, 255)
+            b = constrain(c[2], 0, 255)
+            a = constrain(alpha, 0, 1)
+        else:
+            r = g = b = 0
+            a = 1
+    elif isinstance(c, int):
+        r = g = b = constrain(c, 0, 255)
+        a = constrain(alpha, 0, 1)
+    elif isinstance(c, str):
+        rgb = str2rgb(c)
+        r = rgb.get("r", 0)
+        g = rgb.get("g", 0)
+        b = rgb.get("b", 0)
+        a = constrain(alpha, 0, 1)
+    return f"rgba({r}, {g}, {b}, {a})"
+
+
+def blend(color1, color2, proportion):
+    """
+    Blends two hex color strings by the given proportion.
+    proportion: 0 returns color1, 1 returns color2.
+    Returns the blended color as a hex string.
+    """
+    proportion = constrain(proportion, 0, 1)
+    # Ensure the colors start with '#'
+    c1 = color1 if color1.startswith("#") else "#" + color1
+    c2 = color2 if color2.startswith("#") else "#" + color2
+
+    # Regex to test for valid hex color (3 or 6 hex digits)
+    rgx = re.compile(r"^#+([a-fA-F\d]{6}|[a-fA-F\d]{3})$")
+    if rgx.match(c1) and rgx.match(c2):
+        # Remove leading '#' and expand shorthand if necessary.
+        col1 = c1[1:]
+        col2 = c2[1:]
+        if len(col1) == 3:
+            col1 = "".join([ch * 2 for ch in col1])
+        if len(col2) == 3:
+            col2 = "".join([ch * 2 for ch in col2])
+        try:
+            r1 = int(col1[0:2], 16)
+            r2 = int(col2[0:2], 16)
+            r = math_round((1 - proportion) * r1 + proportion * r2)
+            g1 = int(col1[2:4], 16)
+            g2 = int(col2[2:4], 16)
+            g = math_round((1 - proportion) * g1 + proportion * g2)
+            b1 = int(col1[4:6], 16)
+            b2 = int(col2[4:6], 16)
+            b = math_round((1 - proportion) * b1 + proportion * b2)
+            return "#" + hexStr(r) + hexStr(g) + hexStr(b)
+        except Exception:
+            return "#000000"
+    else:
+        return "#000000"
+
+
+def randomColor():
+    """
+    Generates a random hex color string.
+    """
+    r = hexStr(randomInt(0, 255))
+    g = hexStr(randomInt(0, 255))
+    b = hexStr(randomInt(0, 255))
+    return "#" + r + g + b

pydreamplet-0.1.0/pydreamplet/constants.py

@@ -0,0 +1,6 @@
+import math
+
+PI = math.pi
+HALF_PI = math.pi / 2
+TWO_PI = math.pi * 2
+E = math.e

pydreamplet-0.1.0/pydreamplet/core.py

@@ -0,0 +1,266 @@
+import xml.etree.ElementTree as ET
+
+from IPython.display import SVG as IPythonSVG
+from IPython.display import display
+
+from pydreamplet.constants import PI
+
+SVG_NS = "http://www.w3.org/2000/svg"
+ET.register_namespace("", SVG_NS)
+
+
+def qname(tag):
+    return f"{{{SVG_NS}}}{tag}"
+
+
+class SvgElement:
+    def __init__(self, tag, **kwargs):
+        # Use object.__setattr__ to avoid triggering our custom __setattr__
+        object.__setattr__(self, "element", ET.Element(qname(tag)))
+        for k, v in self.normalize_attrs(kwargs).items():
+            self.element.set(k, str(v))
+
+    @staticmethod
+    def normalize_attrs(attrs):
+        """Convert keys replacing underscores with hyphens."""
+        return {k.replace("_", "-"): str(v) for k, v in attrs.items()}
+
+    def attrs(self, attributes):
+        for key, value in self.normalize_attrs(attributes).items():
+            self.element.set(key, value)
+        return self
+
+    def append(self, child):
+        if hasattr(child, "element"):
+            self.element.append(child.element)
+        else:
+            self.element.append(child)
+
+    def remove(self, child):
+        if hasattr(child, "element"):
+            self.element.remove(child.element)
+        else:
+            self.element.remove(child)
+
+    def tostring(self):
+        return ET.tostring(self.element, encoding="unicode")
+
+    def __str__(self):
+        return self.tostring()
+
+    def __getattr__(self, name):
+        # This is only called if the attribute wasn't found normally.
+        attr_name = name.replace("_", "-")
+        if attr_name in self.element.attrib:
+            val = self.element.attrib[attr_name]
+            # Try to convert to a number if possible.
+            try:
+                # If there's no decimal point or exponent, convert to int.
+                if "." not in val and "e" not in val.lower():
+                    return int(val)
+                else:
+                    return float(val)
+            except ValueError:
+                # If conversion fails, return the original string.
+                return val
+        raise AttributeError(
+            f"{type(self).__name__!r} object has no attribute {name!r}"
+        )
+
+    def __setattr__(self, name, value):
+        # If the attribute is one of our internal attributes or methods,
+        # set it normally. Otherwise, store it as an SVG attribute.
+        if name == "element" or name.startswith("_") or hasattr(type(self), name):
+            object.__setattr__(self, name, value)
+        else:
+            # Convert underscores to hyphens for attribute names.
+            self.element.set(name.replace("_", "-"), str(value))
+
+
+class SVG(SvgElement):
+    def __init__(
+        self, dimensions=(300, 300), viewbox: tuple[int] | None = None, **kwargs
+    ):
+        """
+        Create an SVG root element.
+
+        Parameters:
+          dimensions: tuple with 2 numbers [width, height] (e.g. (300, 300))
+          viewbox: tuple of 2 or 4 numbers.
+                   - If 2 numbers, treated as [width, height] with origin (0, 0).
+                   - If 4 numbers, treated as [minX, minY, width, height].
+        """
+        super().__init__("svg", **kwargs)
+        self.attrs({"width": dimensions[0], "height": dimensions[1]})
+        if not viewbox:
+            vb = f"0 0 {dimensions[0]} {dimensions[1]}"
+        else:
+            if len(viewbox) == 4:
+                vb = f"{viewbox[0]} {viewbox[1]} {viewbox[2]} {viewbox[3]}"
+            elif len(viewbox) == 2:
+                vb = f"0 0 {viewbox[0]} {viewbox[1]}"
+            else:
+                raise ValueError("viewbox must be a list or tuple of 2 or 4 numbers")
+        self.attrs({"viewBox": vb})
+
+    def display(self):
+        display(IPythonSVG(self.tostring()))
+
+    def save(self, filename):
+        with open(filename, "w") as f:
+            f.write(self.tostring())
+
+
+class Animate(SvgElement):
+    def __init__(self, **kwargs):
+        """
+        Create an animate element. Accepts attributes like attributeName, from, to, etc.
+        """
+        super().__init__("animate", **kwargs)
+        self._repeat_count: int | str = "indefinite"
+        self._values: list[int] = []
+        self.attrs(
+            {
+                "attributeType": "XML",
+                "repeatCount": self._repeat_count,
+            }
+        )
+
+    @property
+    def repeat_count(self) -> int | str:
+        return self._repeat_count
+
+    @repeat_count.setter
+    def repeat_count(self, value):
+        self._repeat_count = value
+        self.attrs({"repeatCount": value})
+
+    @property
+    def values(self) -> list[str]:
+        return self._values
+
+    @values.setter
+    def values(self, value):
+        self._values = value
+        self.attrs({"values": ";".join([str(v) for v in value])})
+
+
+class Circle(SvgElement):
+    def __init__(self, **kwargs):
+        """
+        Create a circle element. Accepts attributes like cx, cy, r, etc.
+        """
+        super().__init__("circle", **kwargs)
+
+    @property
+    def radius(self):
+        return float(self.element.get("r", 0))
+
+    @property
+    def center(self):
+        return (float(self.element.get("cx", 0)), float(self.element.get("cy", 0)))
+
+    @property
+    def diameter(self):
+        return self.radius * 2
+
+    @property
+    def area(self):
+        return PI * self.radius**2
+
+
+class Ellipse(SvgElement):
+    def __init__(self, **kwargs):
+        """
+        Create an ellipse element. Accepts attributes like cx, cy, rx, ry, etc.
+        """
+        super().__init__("ellipse", **kwargs)
+
+
+class Rect(SvgElement):
+    def __init__(self, **kwargs):
+        """
+        Create a rectangle element. Accepts attributes like x, y, width, height, etc.
+        """
+        super().__init__("rect", **kwargs)
+
+
+class Text(SvgElement):
+    def __init__(self, initial_text="", **kwargs):
+        """
+        Create a text element.
+
+        Args:
+          initial_text: The initial text to display.
+          kwargs: Additional SVG attributes (e.g. font_family, font_size, font_weight).
+        """
+        super().__init__("text", **kwargs)
+        self._raw_text = initial_text
+        if initial_text:
+            self.content = initial_text  # Use the property setter
+
+    @property
+    def content(self) -> str:
+        """Return the current text content (raw string)."""
+        return self._raw_text
+
+    @content.setter
+    def content(self, new_text: str):
+        """Update the text content and rebuild child <tspan> elements as needed."""
+        self._raw_text = new_text
+        # Clear any existing child elements.
+        for child in list(self.element):
+            self.element.remove(child)
+
+        if "\n" in new_text:
+            self.element.text = None
+            lines = new_text.split("\n")
+            for i, line in enumerate(lines):
+                tspan = ET.Element(qname("tspan"))
+                # For the first line, if x and y exist on the parent, set them.
+                if i == 0:
+                    if "x" in self.element.attrib:
+                        tspan.set("x", self.element.attrib["x"])
+                    if "y" in self.element.attrib:
+                        tspan.set("y", self.element.attrib["y"])
+                else:
+                    # For subsequent lines, copy x and add a dy offset.
+                    if "x" in self.element.attrib:
+                        tspan.set("x", self.element.attrib["x"])
+                    try:
+                        dy_val = float(self.element.attrib.get("font-size", 16))
+                    except ValueError:
+                        dy_val = 16
+                    tspan.set("dy", str(dy_val))
+                tspan.text = line
+                self.element.append(tspan)
+        else:
+            # For single-line text, set the text directly.
+            self.element.text = new_text
+
+    # def dimensions(self, measurer: TypographyMeasurer) -> tuple[float, float]:
+    #     """
+    #     Returns the (width, height) of the text element using the TypographyMeasurer.
+    #     Uses the stored raw text and relevant font attributes.
+    #     """
+    #     font_family = self.element.attrib.get("font-family", "Arial")
+    #     try:
+    #         font_size = float(self.element.attrib.get("font-size", "16"))
+    #     except ValueError:
+    #         font_size = 16
+    #     try:
+    #         font_weight = int(self.element.attrib.get("font-weight", 400))
+    #     except ValueError:
+    #         font_weight = 400
+
+    #     return measurer.measure_text(
+    #         self._raw_text, font_family, font_weight, font_size
+    #     )
+
+    # def width(self, measurer: TypographyMeasurer) -> float:
+    #     """Return the width of the text element."""
+    #     return self.dimensions(measurer)[0]
+
+    # def height(self, measurer: TypographyMeasurer) -> float:
+    #     """Return the height of the text element."""
+    #     return self.dimensions(measurer)[1]

pydreamplet-0.1.0/pydreamplet/scales.py

@@ -0,0 +1,137 @@
+import math
+from collections.abc import Callable
+
+
+def linear_scale(
+    domain: tuple[float, float], range_: tuple[float, float]
+) -> Callable[[float], float]:
+    """
+    Linearly maps a value from the input domain to the output range.
+    """
+    d0, d1 = domain
+    r0, r1 = range_
+
+    def scale(value: float) -> float:
+        return ((value - d0) / (d1 - d0)) * (r1 - r0) + r0
+
+    return scale
+
+
+def band_scale(
+    domain: list[str], range_: tuple[float, float], padding: float = 0.1
+) -> Callable[[str], float | None]:
+    """
+    Maps categorical values (strings) to evenly spaced positions in the range.
+    The returned function also carries a `bandwidth` attribute that gives the computed band width.
+    """
+    r0, r1 = range_
+    n = len(domain)
+    if n == 0:
+        raise ValueError("Domain must contain at least one value")
+    # Compute the step: total range divided by number of bands plus gaps
+    step = (r1 - r0) / (n + padding * (n - 1))
+    # Each band takes (1 - padding) portion of the step.
+    band_width = step * (1 - padding)
+
+    def scale(value: str) -> float | None:
+        try:
+            index = domain.index(value)
+            # Position is offset by index * step * (1 + padding)
+            return r0 + index * step * (1 + padding)
+        except ValueError:
+            return None  # value not found in the domain
+
+    # Attach a bandwidth method to the scale function.
+    scale.bandwidth = lambda: band_width  # type: ignore
+    return scale
+
+
+def point_scale(
+    domain: list[str], range_: tuple[float, float], padding: float = 0.5
+) -> Callable[[str], float | None]:
+    """
+    Maps categorical values to points in the range, placing padding at both ends.
+    """
+    r0, r1 = range_
+    n = len(domain)
+    if n == 0:
+        raise ValueError("Domain must contain at least one value")
+    # Compute step based on (n - 1) intervals plus padding on each end.
+    step = (r1 - r0) / (n - 1 + 2 * padding)
+
+    def scale(value: str) -> float | None:
+        try:
+            index = domain.index(value)
+            return r0 + step * (index + padding)
+        except ValueError:
+            return None
+
+    return scale
+
+
+def ordinal_scale(domain: list[str], range_: list) -> Callable[[str], object]:
+    """
+    Maps categorical values to a set of output values in a cyclic fashion.
+    """
+    if not range_:
+        raise ValueError("Range must contain at least one value")
+    mapping = {d: range_[i % len(range_)] for i, d in enumerate(domain)}
+
+    def scale(value: str) -> object:
+        return mapping.get(value)
+
+    return scale
+
+
+def square_scale(
+    domain: tuple[float, float], range_: tuple[float, float]
+) -> Callable[[float], float]:
+    """
+    Maps an input value (e.g. an area) to an output using a square-root transformation.
+
+    This is useful when the visual representation (like the side length of a square)
+    should be proportional to the square root of the area so that the actual area
+    is proportional to the input value.
+
+    The transformation is defined as:
+        scale(value) = r0 + ((sqrt(value) - sqrt(d0)) / (sqrt(d1) - sqrt(d0))) * (r1 - r0)
+    """
+    d0, d1 = domain
+    r0, r1 = range_
+    if d0 < 0 or d1 < 0:
+        raise ValueError("Domain values must be non-negative for square scale")
+    sqrt_d0, sqrt_d1 = math.sqrt(d0), math.sqrt(d1)
+    if sqrt_d1 == sqrt_d0:
+        raise ValueError("Invalid domain: sqrt(d1) and sqrt(d0) cannot be equal")
+
+    def scale(value: float) -> float:
+        return r0 + ((math.sqrt(value) - sqrt_d0) / (sqrt_d1 - sqrt_d0)) * (r1 - r0)
+
+    return scale
+
+
+def circle_scale(
+    domain: tuple[float, float], range_: tuple[float, float]
+) -> Callable[[float], float]:
+    """
+    Maps an input value to the radius of a circle such that the circle's area is linearly
+    proportional to the input value.
+
+    If the input domain is (d0, d1) and the desired radius range is (r0, r1), then the area of the circle
+    will vary from π·r0² to π·r1². The mapping is given by:
+
+        radius(v) = sqrt( ((v - d0) / (d1 - d0)) * (r1² - r0²) + r0² )
+
+    This way, if you use π·radius(v)² as the circle’s area, it will be proportional to v.
+    """
+    d0, d1 = domain
+    r0, r1 = range_
+    if d1 == d0:
+        raise ValueError("Domain values must be distinct")
+
+    def scale(value: float) -> float:
+        # Linearly interpolate between r0^2 and r1^2, then take the square root.
+        r_squared = ((value - d0) / (d1 - d0)) * (r1 * r1 - r0 * r0) + r0 * r0
+        return math.sqrt(r_squared)
+
+    return scale

pydreamplet-0.1.0/pydreamplet/typography.py

@@ -0,0 +1,160 @@
+import os
+import platform
+
+from fontTools.ttLib import TTFont
+from PIL import Image, ImageDraw, ImageFont
+
+
+def get_system_font_path(
+    font_family: str, weight: int = 400, weight_tolerance: int = 100
+) -> str | None:
+    """
+    Search common system directories for a TrueType or OpenType font file (.ttf/.otf)
+    that matches the requested font_family and is within a specified tolerance of the desired weight.
+
+    Args:
+        font_family: The desired system font name (e.g. "Arial").
+        weight: Numeric weight (e.g., 400 for regular, 700 for bold).
+        weight_tolerance: Allowed difference between the desired weight and the font's actual weight.
+
+    Returns:
+        The full path to the matching font file, or None if no match is found.
+    """
+    system = platform.system()
+    font_dirs = []
+
+    if system == "Windows":
+        # System-wide fonts directory.
+        system_fonts = os.path.join(os.environ.get("WINDIR", "C:\\Windows"), "Fonts")
+        font_dirs.append(system_fonts)
+        # User-specific fonts directory.
+        local_fonts = os.path.join(
+            os.environ.get("LOCALAPPDATA", ""), "Microsoft", "Windows", "Fonts"
+        )
+        if local_fonts and os.path.exists(local_fonts):
+            font_dirs.append(local_fonts)
+    elif system == "Darwin":
+        font_dirs = [
+            "/System/Library/Fonts",
+            "/Library/Fonts",
+            os.path.expanduser("~/Library/Fonts"),
+        ]
+    else:
+        # Assume Linux/Unix.
+        font_dirs = [
+            "/usr/share/fonts",
+            os.path.expanduser("~/.fonts"),
+            "/usr/local/share/fonts",
+        ]
+
+    # Consider both TTF and OTF files.
+    extensions = (".ttf", ".otf")
+
+    for font_dir in font_dirs:
+        if not os.path.exists(font_dir):
+            continue
+        for root, dirs, files in os.walk(font_dir):
+            for file in files:
+                if not file.lower().endswith(extensions):
+                    continue
+
+                file_path = os.path.join(root, file)
+                try:
+                    font = TTFont(file_path)
+                except Exception:
+                    continue
+
+                # Loop over all name records for a looser match.
+                family_matches = False
+                for record in font["name"].names:
+                    try:
+                        record_value = record.toUnicode().strip()
+                    except Exception:
+                        record_value = record.string.decode(
+                            "utf-8", errors="ignore"
+                        ).strip()
+                    if font_family.lower() in record_value.lower():
+                        family_matches = True
+                        break
+                if not family_matches:
+                    continue
+
+                # If the OS/2 table exists, check the weight.
+                if "OS/2" in font:
+                    os2_table = font["OS/2"]
+                    font_weight = getattr(os2_table, "usWeightClass", 400)
+                    if abs(font_weight - weight) <= weight_tolerance:
+                        return file_path
+                    else:
+                        continue  # Weight doesn't match, keep searching.
+                else:
+                    # If no OS/2 table exists, return the first matching family.
+                    return file_path
+    return None
+
+
+class TypographyMeasurer:
+    def __init__(self, dpi: float = 72.0, font_path: str | None = None):
+        """
+        Initialize with a given DPI (dots per inch). The default is 72 DPI,
+        meaning 1 point equals 1 pixel. With higher DPI values, the point-to-pixel
+        conversion increases accordingly.
+
+        If a font_path is provided, it will be used; otherwise the system is searched.
+        """
+        self.dpi = dpi
+        self.font_path = font_path
+
+    def measure_text(
+        self,
+        text: str,
+        font_family: str | None = None,
+        weight: int | None = None,
+        font_size: float = 12.0,
+    ) -> tuple[float, float]:
+        """
+        Measure the width and height of the given text rendered in the specified font.
+        Supports multiline text if newline characters are present.
+
+        Args:
+            text: The text to measure.
+            font_family: The system font name (e.g., "Arial"). Optional if self.font_path is provided.
+            weight: Numeric weight (e.g., 400 for regular, 700 for bold). Optional if self.font_path is provided.
+            font_size: The desired font size in points.
+
+        Returns:
+            A tuple (width, height) in pixels.
+
+        Raises:
+            ValueError: If the specified font cannot be found and font_family or weight are missing.
+        """
+        # If no font_path is already set, require font_family and weight.
+        if not self.font_path:
+            if font_family is None or weight is None:
+                raise ValueError(
+                    "A font path was not provided and font_family and weight are required to search for a font."
+                )
+            self.font_path = get_system_font_path(font_family, weight)
+        if self.font_path is None:
+            raise ValueError(
+                f"Font '{font_family}' with weight {weight} not found on the system."
+            )
+
+        # Convert point size to pixel size using DPI conversion.
+        pixel_size = font_size * self.dpi / 72.0
+        # ImageFont.truetype expects an integer size.
+        font = ImageFont.truetype(self.font_path, int(pixel_size))
+
+        # Create a dummy image for measurement.
+        dummy_img = Image.new("RGB", (1000, 1000))
+        draw = ImageDraw.Draw(dummy_img)
+
+        # Use multiline_textbbox if there are newline characters.
+        if "\n" in text:
+            bbox = draw.multiline_textbbox((0, 0), text, font=font)
+        else:
+            bbox = draw.textbbox((0, 0), text, font=font)
+
+        width = bbox[2] - bbox[0]
+        height = bbox[3] - bbox[1]
+        return float(width), float(height)

pydreamplet-0.1.0/pydreamplet/utils.py

@@ -0,0 +1,10 @@
+def math_round(x):
+    """
+    Rounds x to the nearest integer using round half up.
+    """
+    return int(x + 0.5)
+
+
+def constrain(value, min_val, max_val):
+    """Constrain value between min_val and max_val."""
+    return max(min_val, min(value, max_val))

pydreamplet-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "pydreamplet"
+version = "0.1.0"
+description = "A library for assembling SVGs from Python"
+authors = [{ name = "Marek Pilczuk", email = "user@mp76.pl" }]
+license = "MIT"
+readme = "README.md"
+keywords = ["svg", "graphics", "design"]
+requires-python = ">=3.12"
+dependencies = [
+    "pillow (>=11.1.0,<12.0.0)",
+    "fonttools (>=4.56.0,<5.0.0)",
+    "ipython (>=8.32.0,<9.0.0)",
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.group.dev.dependencies]
+jupyter = "^1.1.1"
+ruff = "^0.9.5"
+pytest = "^8.3.4"