psd2svg 0.3.0__py3-none-any.whl

psd2svg/__init__.py

@@ -0,0 +1,3 @@
+from psd2svg.svg_document import SVGDocument, convert
+
+__all__ = ["SVGDocument", "convert"]

psd2svg/__main__.py

@@ -0,0 +1,87 @@
+import argparse
+import logging
+
+from psd2svg import convert
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="Convert PSD file to SVG")
+    parser.add_argument(
+        "input", metavar="INPUT", type=str, help="Input PSD file path or URL"
+    )
+    parser.add_argument(
+        "output",
+        metavar="PATH",
+        type=str,
+        nargs="?",
+        default=".",
+        help="Output file.",
+    )
+    parser.add_argument(
+        "--image-prefix",
+        metavar="PATH",
+        type=str,
+        default=None,
+        help="Path prefix for saving extracted images relative to output.",
+    )
+    parser.add_argument(
+        "--no-text",
+        dest="enable_text",
+        action="store_false",
+        help="Disable text layer conversion (rasterize text instead).",
+    )
+    parser.add_argument(
+        "--no-live-shapes",
+        dest="enable_live_shapes",
+        action="store_false",
+        help="Disable live shape conversion (use paths instead of shape primitives).",
+    )
+    parser.add_argument(
+        "--no-title",
+        dest="enable_title",
+        action="store_false",
+        help="Disable insertion of <title> elements with layer names.",
+    )
+    parser.add_argument(
+        "--image-format",
+        metavar="FORMAT",
+        type=str,
+        choices=["webp", "png", "jpeg"],
+        default="webp",
+        help="Image format for rasterized layers (webp, png, jpeg). Default: webp",
+    )
+    parser.add_argument(
+        "--text-letter-spacing-offset",
+        metavar="OFFSET",
+        type=float,
+        default=0.0,
+        help="Global offset (in pixels) to add to letter-spacing values. Default: 0.0",
+    )
+    parser.add_argument(
+        "--loglevel",
+        metavar="LEVEL",
+        default="WARNING",
+        help="Logging level, default WARNING",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    """Main function to convert PSD to SVG or raster image."""
+    args = parse_args()
+    logging.basicConfig(level=getattr(logging, args.loglevel.upper(), "WARNING"))
+    convert(
+        args.input,
+        args.output,
+        image_prefix=args.image_prefix,
+        enable_text=args.enable_text,
+        enable_live_shapes=args.enable_live_shapes,
+        enable_title=args.enable_title,
+        image_format=args.image_format,
+        text_letter_spacing_offset=args.text_letter_spacing_offset,
+    )
+
+
+if __name__ == "__main__":
+    main()

psd2svg/core/adjustment.py

@@ -0,0 +1,106 @@
+"""Mixin for adjustment layers conversion.
+
+Due to the limited support of BackgroundImage in SVG filters, our approach wraps
+the backdrop elements into a symbol, and use two <use> elements to apply the filter.
+
+When we have a layer structure like this::
+
+    <layer 1 />
+    <layer 2 />
+    <adjustment />
+
+We convert it into the following SVG structure::
+
+    <symbol id="backdrop">
+        <image id="layer1" ... />
+        <image id="layer2" ... />
+    </symbol>
+    <filter id="adjustment"></filter>
+    <use href="#backdrop" />
+    <use href="#backdrop" filter="url(#adjustment)" />
+
+
+This approach may have limitations when the backdrop has transparency, as the
+stacked use elements may not produce the intended visual result.
+"""
+
+import logging
+import xml.etree.ElementTree as ET
+
+from psd_tools.api import adjustments, layers
+
+from psd2svg import svg_utils
+from psd2svg.core.base import ConverterProtocol
+
+logger = logging.getLogger(__name__)
+
+
+class AdjustmentConverter(ConverterProtocol):
+    """Mixin for adjustment layers."""
+
+    def add_adjustment(
+        self, layer: layers.AdjustmentLayer, **attrib: str
+    ) -> ET.Element | None:
+        """Add an adjustment layer to the svg document."""
+        logger.warning(
+            f"Adjustment layer is unsupported yet: '{layer.name}' ({layer.kind})"
+        )
+        return None
+
+    def add_invert_adjustment(
+        self, layer: adjustments.Invert, **attrib: str
+    ) -> ET.Element | None:
+        """Add an invert adjustment layer to the svg document."""
+        filter, use = self._create_filter(layer, name="invert", **attrib)
+        fe_component = svg_utils.create_node(
+            "feComponentTransfer", parent=filter, color_interpolation_filters="sRGB"
+        )
+        svg_utils.create_node(
+            "feFuncR", parent=fe_component, type="table", tableValues="1 0"
+        )
+        svg_utils.create_node(
+            "feFuncG", parent=fe_component, type="table", tableValues="1 0"
+        )
+        svg_utils.create_node(
+            "feFuncB", parent=fe_component, type="table", tableValues="1 0"
+        )
+        return use
+
+    def _create_filter(
+        self, layer: layers.AdjustmentLayer, name: str, **attrib: str
+    ) -> tuple[ET.Element, ET.Element]:
+        """Create SVG filter structure for the adjustment layer."""
+        wrapper = self._wrap_backdrop("symbol", id=self.auto_id("backdrop"))
+        filter = self.create_node("filter", id=self.auto_id(name))
+        # Backdrop use.
+        self.create_node(
+            "use",
+            href=f"#{wrapper.get('id')}",
+        )
+        # Apply filter to the use.
+        use = self.create_node(
+            "use",
+            href=f"#{wrapper.get('id')}",
+            filter=f"url(#{filter.get('id')})",
+            class_=name,
+            **attrib,  # type: ignore[arg-type]  # Clipping context etc.
+        )
+        self.set_layer_attributes(layer, use)
+        use = self.apply_mask(layer, use)
+        return filter, use
+
+    def _wrap_backdrop(self, tag: str = "symbol", **attrib: str) -> ET.Element:
+        """Wrap previous nodes into a container node for adjustment application."""
+        # TODO: Find the appropriate container in the clipping context, as the parent is mask or clipPath.
+        if self.current.tag == "clipPath" or self.current.tag == "mask":
+            logger.warning(
+                "Wrapping backdrop inside clipping/mask context is not supported yet."
+            )
+        siblings = list(self.current)
+        if not siblings:
+            logger.warning("No backdrop elements found to wrap for adjustment.")
+        wrapper = self.create_node(tag, **attrib)  # type: ignore[arg-type]
+        for node in siblings:
+            self.current.remove(node)
+            wrapper.append(node)
+        return wrapper

psd2svg/core/base.py

@@ -0,0 +1,135 @@
+import contextlib
+import xml.etree.ElementTree as ET
+from typing import TYPE_CHECKING, Any, Iterator, Protocol
+
+from PIL import Image
+from psd_tools import PSDImage
+from psd_tools.api import adjustments, layers
+from psd_tools.constants import BlendMode
+from psd_tools.psd.descriptor import Descriptor
+
+if TYPE_CHECKING:
+    from psd2svg.core.font_utils import FontInfo
+
+
+class ConverterProtocol(Protocol):
+    """Converter state protocol."""
+
+    psd: PSDImage
+    svg: ET.Element
+    current: ET.Element
+    images: list[Image.Image]
+    fonts: dict[str, "FontInfo"]
+
+    # Flags to control the conversion.
+    enable_live_shapes: bool
+    enable_text: bool
+    enable_title: bool
+
+    def add_layer(self, layer: layers.Layer, **attrib: str) -> ET.Element | None: ...
+    def add_group(self, layer: layers.Group, **attrib: str) -> ET.Element | None: ...
+    def add_pixel(self, layer: layers.Layer, **attrib: str) -> ET.Element | None: ...
+    def add_shape(
+        self, layer: layers.ShapeLayer, **attrib: str
+    ) -> ET.Element | None: ...
+    def add_adjustment(
+        self, layer: layers.AdjustmentLayer, **attrib: str
+    ) -> ET.Element | None: ...
+    def add_text(self, layer: layers.TypeLayer, **attrib: str) -> ET.Element | None: ...
+    def add_fill(
+        self,
+        layer: adjustments.SolidColorFill
+        | adjustments.GradientFill
+        | adjustments.PatternFill,
+        **attrib: str,
+    ) -> ET.Element | None: ...
+
+    # Layer attributes
+    def set_layer_attributes(self, layer: layers.Layer, node: ET.Element) -> None: ...
+    def set_isolation(self, layer: layers.Layer, node: ET.Element) -> None: ...
+    def apply_mask(self, layer: layers.Layer, node: ET.Element) -> ET.Element: ...
+    def set_opacity(self, opacity: float, node: ET.Element) -> None: ...
+    def set_blend_mode(self, psd_mode: bytes | BlendMode, node: ET.Element) -> None: ...
+    def add_linear_gradient(self, setting: Descriptor) -> ET.Element: ...
+    def add_radial_gradient(self, setting: Descriptor) -> ET.Element: ...
+    def add_pattern(self, psdimage: PSDImage, descriptor: Descriptor) -> ET.Element: ...
+
+    # Shape methods
+    def create_shape(self, layer: layers.ShapeLayer, **attrib: Any) -> ET.Element: ...
+
+    # Text methods
+    def create_text_node(self, layer: layers.TypeLayer) -> ET.Element: ...
+
+    # Paint methods
+    def apply_vector_fill(
+        self, layer: layers.ShapeLayer | adjustments.FillLayer, target: ET.Element
+    ) -> None: ...
+    def apply_vector_stroke(
+        self, layer: layers.ShapeLayer | adjustments.FillLayer, target: ET.Element
+    ) -> None: ...
+    def set_fill(
+        self, layer: layers.ShapeLayer | adjustments.FillLayer, node: ET.Element
+    ) -> None: ...
+    def set_stroke(
+        self, layer: layers.ShapeLayer | adjustments.FillLayer, node: ET.Element
+    ) -> None: ...
+
+    # Layer effects
+    def apply_background_effects(
+        self, layer: layers.Layer, target: ET.Element, insert_before_target: bool = True
+    ) -> None: ...
+    def apply_overlay_effects(
+        self, layer: layers.Layer, target: ET.Element
+    ) -> None: ...
+    def apply_drop_shadow_effect(
+        self,
+        layer: layers.Layer,
+        target: ET.Element,
+        insert_before_target: bool = False,
+    ) -> None: ...
+    def apply_outer_glow_effect(
+        self,
+        layer: layers.Layer,
+        target: ET.Element,
+        insert_before_target: bool = False,
+    ) -> None: ...
+    def apply_color_overlay_effect(
+        self, layer: layers.Layer, target: ET.Element
+    ) -> None: ...
+    def apply_gradient_overlay_effect(
+        self, layer: layers.Layer, target: ET.Element
+    ) -> None: ...
+    def apply_pattern_overlay_effect(
+        self, layer: layers.Layer, target: ET.Element
+    ) -> None: ...
+    def apply_inner_shadow_effect(
+        self, layer: layers.Layer, target: ET.Element
+    ) -> None: ...
+    def apply_inner_glow_effect(
+        self, layer: layers.Layer, target: ET.Element
+    ) -> None: ...
+    def apply_satin_effect(self, layer: layers.Layer, target: ET.Element) -> None: ...
+    def apply_bevel_emboss_effect(
+        self, layer: layers.Layer, target: ET.Element
+    ) -> None: ...
+    def apply_stroke_effect(self, layer: layers.Layer, target: ET.Element) -> None: ...
+
+    # Adjustments
+    def add_invert_adjustment(
+        self, layer: adjustments.Invert, **attrib: str
+    ) -> ET.Element | None: ...
+
+    # Utilities
+    def auto_id(self, prefix: str = "") -> str: ...
+    def create_node(
+        self,
+        tag: str,
+        parent: ET.Element | None = None,
+        class_: str = "",
+        title: str = "",
+        text: str = "",
+        desc: str = "",
+        **kwargs: Any,
+    ) -> ET.Element: ...
+    @contextlib.contextmanager
+    def set_current(self, node: ET.Element) -> Iterator[None]: ...

psd2svg/core/color_utils.py

@@ -0,0 +1,82 @@
+import logging
+from typing import Sequence
+
+from psd_tools.psd.descriptor import Descriptor
+from psd_tools.terminology import Klass, Enum
+
+logger = logging.getLogger(__name__)
+
+
+def rgb2hex(values: Sequence[int]) -> str:
+    """Convert RGB color to hex string."""
+    assert len(values) == 3
+    return (
+        f"#{clip_int(values[0]):02x}{clip_int(values[1]):02x}{clip_int(values[2]):02x}"
+    )
+
+
+def rgba2hex(values: Sequence[int], alpha: float = 1.0) -> str:
+    """Convert RGBA color to hex string, considering alpha channel."""
+    assert len(values) == 3
+    if alpha >= 1.0:
+        return rgb2hex(values)
+    r = clip_int(values[0])
+    g = clip_int(values[1])
+    b = clip_int(values[2])
+    a = max(0, min(255, int(alpha * 255)))
+    return f"#{r:02x}{g:02x}{b:02x}{a:02x}"
+
+
+def cmyk2rgb(values: Sequence[float]) -> tuple[int, int, int]:
+    """Convert CMYK color to RGB color."""
+    assert len(values) == 4
+    return (
+        clip_int(2.55 * (1.0 - values[0]) * (1.0 - values[3])),
+        clip_int(2.55 * (1.0 - values[1]) * (1.0 - values[3])),
+        clip_int(2.55 * (1.0 - values[2]) * (1.0 - values[3])),
+    )
+
+
+def descriptor2hex(desc: Descriptor, fallback: str = "transparent") -> str:
+    """Convert a color descriptor to an RGB hex string."""
+
+    if desc.classID == Klass.RGBColor:
+        if Enum.Red in desc:
+            r = desc.get(Enum.Red, 0)
+            g = desc.get(Enum.Green, 0)
+            b = desc.get(Enum.Blue, 0)
+            return f"#{int(r):02x}{int(g):02x}{int(b):02x}"
+        elif "redFloat" in desc:
+            r = float2uint8(desc.get("redFloat", 0))
+            g = float2uint8(desc.get("greenFloat", 0))
+            b = float2uint8(desc.get("blueFloat", 0))
+            return f"#{r:02x}{g:02x}{b:02x}"
+        else:
+            raise ValueError(f"Unsupported RGB color format: {desc}")
+
+    if desc.classID == Klass.CMYKColor:
+        c = desc.get(Enum.Cyan, 0)
+        m = desc.get(Enum.Magenta, 0)
+        y = desc.get(Enum.Yellow, 0)
+        k = desc.get(Enum.Black, 0)
+        r, g, b = cmyk2rgb((c / 100, m / 100, y / 100, k / 100))
+        return f"#{r:02x}{g:02x}{b:02x}"
+
+    if desc.classID == Klass.Grayscale:
+        gray = desc.get(Enum.Gray, 0)
+        assert isinstance(gray, float)
+        gray = float2uint8(gray)
+        return f"#{gray:02x}{gray:02x}{gray:02x}"
+
+    logger.warning("Unsupported color mode: %s", desc.classID)
+    return fallback
+
+
+def float2uint8(v: float) -> int:
+    """Convert a float in the range [0.0, 1.0] to an integer in the range [0, 255]."""
+    return clip_int(255 * v)
+
+
+def clip_int(value: int | float, min_value: int = 0, max_value: int = 255) -> int:
+    """Clip an int value to the specified range."""
+    return max(min_value, min(max_value, int(value)))

psd2svg/core/constants.py

@@ -0,0 +1,98 @@
+from typing import Union
+
+from psd_tools.constants import BlendMode
+from psd_tools.terminology import Enum
+
+# https://helpx.adobe.com/photoshop/using/blending-modes.html
+BLEND_MODE: dict[Union[BlendMode, bytes], str] = {
+    # Layer modes.
+    BlendMode.PASS_THROUGH: "pass-through",
+    BlendMode.NORMAL: "normal",
+    BlendMode.DISSOLVE: "normal",
+    BlendMode.DARKEN: "darken",
+    BlendMode.MULTIPLY: "multiply",
+    BlendMode.COLOR_BURN: "color-burn",
+    BlendMode.LINEAR_BURN: "plus-darker",
+    BlendMode.DARKER_COLOR: "darken",
+    BlendMode.LIGHTEN: "lighten",
+    BlendMode.SCREEN: "screen",
+    BlendMode.COLOR_DODGE: "color-dodge",
+    BlendMode.LINEAR_DODGE: "plus-lighter",
+    BlendMode.LIGHTER_COLOR: "lighten",
+    BlendMode.OVERLAY: "overlay",
+    BlendMode.SOFT_LIGHT: "soft-light",
+    BlendMode.HARD_LIGHT: "hard-light",
+    BlendMode.VIVID_LIGHT: "lighten",
+    BlendMode.LINEAR_LIGHT: "darken",
+    BlendMode.PIN_LIGHT: "normal",
+    BlendMode.HARD_MIX: "normal",
+    BlendMode.DIFFERENCE: "difference",
+    BlendMode.EXCLUSION: "exclusion",
+    BlendMode.SUBTRACT: "difference",
+    BlendMode.DIVIDE: "difference",
+    BlendMode.HUE: "hue",
+    BlendMode.SATURATION: "saturation",
+    BlendMode.COLOR: "color",
+    BlendMode.LUMINOSITY: "luminosity",
+    # Descriptor values.
+    Enum.Normal: "normal",
+    Enum.Dissolve: "normal",
+    Enum.Darken: "darken",
+    Enum.Multiply: "multiply",
+    Enum.ColorBurn: "color-burn",
+    b"linearBurn": "plus-darker",
+    b"darkerColor": "darken",
+    Enum.Lighten: "lighten",
+    Enum.Screen: "screen",
+    Enum.ColorDodge: "color-dodge",
+    b"linearDodge": "plus-lighter",
+    b"lighterColor": "lighten",
+    Enum.Overlay: "overlay",
+    Enum.SoftLight: "soft-light",
+    Enum.HardLight: "hard-light",
+    b"vividLight": "lighten",
+    b"linearLight": "darken",
+    b"pinLight": "normal",
+    b"hardMix": "normal",
+    Enum.Difference: "difference",
+    Enum.Exclusion: "exclusion",
+    Enum.Subtract: "difference",
+    b"blendDivide": "difference",
+    Enum.Hue: "hue",
+    Enum.Saturation: "saturation",
+    Enum.Color: "color",
+    Enum.Luminosity: "luminosity",
+}
+
+# Blend modes that are not accurately supported in SVG and are mapped to approximations.
+# These will trigger warnings when used.
+INACCURATE_BLEND_MODES: set[Union[BlendMode, bytes]] = {
+    # Dissolve mode uses random pixel patterns, not supported in SVG
+    BlendMode.DISSOLVE,
+    Enum.Dissolve,
+    # Linear burn uses plus-darker which has limited browser support
+    BlendMode.LINEAR_BURN,
+    b"linearBurn",
+    # Linear dodge uses plus-lighter which has limited browser support
+    BlendMode.LINEAR_DODGE,
+    b"linearDodge",
+    # Darker/Lighter Color modes compare color values, approximated with darken/lighten
+    BlendMode.DARKER_COLOR,
+    b"darkerColor",
+    BlendMode.LIGHTER_COLOR,
+    b"lighterColor",
+    # Advanced light modes approximated with simpler modes
+    BlendMode.VIVID_LIGHT,
+    b"vividLight",
+    BlendMode.LINEAR_LIGHT,
+    b"linearLight",
+    BlendMode.PIN_LIGHT,
+    b"pinLight",
+    BlendMode.HARD_MIX,
+    b"hardMix",
+    # Subtract and Divide modes approximated with difference
+    BlendMode.SUBTRACT,
+    Enum.Subtract,
+    BlendMode.DIVIDE,
+    b"blendDivide",
+}

psd2svg/core/converter.py

@@ -0,0 +1,173 @@
+import contextlib
+import logging
+import xml.etree.ElementTree as ET
+from typing import Any, Iterator
+
+from PIL import Image
+from psd_tools import PSDImage
+
+from psd2svg import svg_utils
+from psd2svg.core.adjustment import AdjustmentConverter
+from psd2svg.core.counter import AutoCounter
+from psd2svg.core.effects import EffectConverter
+from psd2svg.core.font_utils import FontInfo
+from psd2svg.core.layer import LayerConverter
+from psd2svg.core.paint import PaintConverter
+from psd2svg.core.shape import ShapeConverter
+from psd2svg.core.text import TextConverter
+
+logger = logging.getLogger(__name__)
+
+
+class Converter(
+    AdjustmentConverter,
+    LayerConverter,
+    PaintConverter,
+    ShapeConverter,
+    TextConverter,
+    EffectConverter,
+):
+    """Converter main class.
+
+    Example usage:
+
+        from psd2svg.core.converter import Converter
+
+        Converter.convert("example.psd", "output.svg")
+
+    Example usage:
+
+        from psd_tools import PSDImage
+        from psd2svg.core.conveter import Converter
+
+        psd = PSDImage.open("example.psd")
+        converter = Converter(psd)
+        document = converter.build()
+        document.embed_images()  # or document.export_images("output/image_%02d")
+        svg_string = document.export()
+
+    Args:
+        psdimage: Source PSDImage to convert.
+        enable_live_shapes: Enable live shape conversion when possible.
+        enable_text: Enable text layer conversion when possible.
+        enable_title: Enable insertion of <title> elements with layer names. When True
+            (default), each layer in the SVG will have a <title> element containing the
+            Photoshop layer name for accessibility and debugging. Set to False to omit
+            title elements and reduce file size.
+        text_letter_spacing_offset: Global offset (in pixels) to add to all letter-spacing
+            values. This can be used to compensate for differences between Photoshop's
+            text rendering and SVG's text rendering. Typical values range from -0.02 to 0.02.
+            Default is 0.0 (no offset).
+    """
+
+    _id_counter: AutoCounter | None = None
+
+    def __init__(
+        self,
+        psdimage: PSDImage,
+        enable_live_shapes: bool = True,
+        enable_text: bool = True,
+        enable_title: bool = True,
+        text_letter_spacing_offset: float = 0.0,
+    ) -> None:
+        """Initialize the converter internal state."""
+
+        # Source PSD image.
+        if not isinstance(psdimage, PSDImage):
+            raise TypeError("psdimage must be an instance of PSDImage")
+        self.psd = psdimage
+        self.enable_live_shapes = enable_live_shapes
+        self.enable_text = enable_text
+        self.enable_title = enable_title
+        self.text_letter_spacing_offset = text_letter_spacing_offset
+
+        # Initialize the SVG root element.
+        self.svg = svg_utils.create_node(
+            "svg",
+            xmlns=svg_utils.NAMESPACE,
+            width=psdimage.width,
+            height=psdimage.height,
+            viewBox=svg_utils.seq2str([0, 0, psdimage.width, psdimage.height], sep=" "),
+        )
+        self.images: list[Image.Image] = []  # Store PIL images here.
+        self.fonts: dict[
+            str, FontInfo
+        ] = {}  # Store font info keyed by postscript name.
+
+        # Initialize the current node pointer.
+        self.current = self.svg
+
+    def build(self) -> None:
+        """Build the SVG structure and internally save the result."""
+        assert self.psd is not None, "PSD image is not set."
+
+        if len(self.psd) == 0 and self.psd.has_preview():
+            # Special case: No layers, just a flat image.
+            self.create_node(
+                "image",
+                width=self.psd.width,
+                height=self.psd.height,
+            )
+            self.images.append(self.psd.composite())
+        else:
+            self.add_children(self.psd)
+
+    def auto_id(self, prefix: str = "") -> str:
+        """Generate a unique ID for SVG elements."""
+        if self._id_counter is None:
+            self._id_counter = AutoCounter()
+        return self._id_counter.get_id(prefix)
+
+    def create_node(
+        self,
+        tag: str,
+        parent: ET.Element | None = None,
+        class_: str = "",
+        title: str = "",
+        text: str = "",
+        desc: str = "",
+        **kwargs: Any,
+    ) -> ET.Element:
+        """Create an SVG node with the current element as default parent.
+
+        This is a convenience wrapper around svg_utils.create_node that automatically
+        uses self.current as the parent if no parent is specified.
+
+        Args:
+            tag: The XML tag name.
+            parent: Optional parent element. Defaults to self.current.
+            class_: Optional class attribute.
+            title: Optional title element.
+            text: Optional text content.
+            desc: Optional description element.
+            **kwargs: Additional attributes to pass to svg_utils.create_node.
+
+        Returns:
+            The created XML element.
+        """
+        if parent is None:
+            parent = self.current
+
+        # Conditionally suppress title based on enable_title flag
+        if not self.enable_title:
+            title = ""
+
+        return svg_utils.create_node(
+            tag,
+            parent=parent,
+            class_=class_,
+            title=title,
+            text=text,
+            desc=desc,
+            **kwargs,
+        )
+
+    @contextlib.contextmanager
+    def set_current(self, node: ET.Element) -> Iterator[None]:
+        """Set the current node for the converter."""
+        previous = self.current
+        self.current = node
+        try:
+            yield
+        finally:
+            self.current = previous