SVG2DrawIOLib 1.0.0__py3-none-any.whl

SVG2DrawIOLib/cli/list.py

@@ -0,0 +1,70 @@
+"""List command - List all icons in a DrawIO library."""
+
+import logging
+import sys
+from pathlib import Path
+
+import rich_click as rc
+from rich.table import Table
+
+from SVG2DrawIOLib.cli.helpers import console, setup_logging
+from SVG2DrawIOLib.library_manager import LibraryManager
+
+
+@rc.command(name="list")
+@rc.argument(
+    "library_file",
+    type=rc.Path(exists=True, dir_okay=False, path_type=Path),
+)
+@rc.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Enable verbose debug logging.",
+)
+@rc.option(
+    "--quiet",
+    "-q",
+    is_flag=True,
+    help="Suppress all output except errors.",
+)
+def list(
+    library_file: Path,
+    verbose: bool,
+    quiet: bool,
+) -> None:
+    """List all icons in a DrawIO library.
+
+    \b
+    Displays all icon names in the specified library file.
+
+    Example:
+        List all icons:
+        $ SVG2DrawIOLib list my-library.xml
+    """
+    setup_logging(verbose, quiet)
+    logger = logging.getLogger(__name__)
+
+    try:
+        manager = LibraryManager()
+        icon_names = manager.list_icons(library_file)
+
+        if not icon_names:
+            console.print(f"[yellow]Library is empty:[/yellow] {library_file}")
+            return
+
+        # Create a nice table
+        table = Table(title=f"Icons in {library_file.name}", show_header=True)
+        table.add_column("Icon Name", style="cyan")
+
+        for name in sorted(icon_names):
+            table.add_row(name)
+
+        console.print(table)
+        console.print(f"\n[green]Total:[/green] {len(icon_names)} icon(s)")
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        if verbose:
+            raise
+        sys.exit(1)

SVG2DrawIOLib/cli/remove.py

@@ -0,0 +1,71 @@
+"""Remove command - Remove icons from a DrawIO library by name."""
+
+import logging
+import sys
+from pathlib import Path
+
+import rich_click as rc
+
+from SVG2DrawIOLib.cli.helpers import console, setup_logging
+from SVG2DrawIOLib.library_manager import LibraryManager
+
+
+@rc.command()
+@rc.argument(
+    "library_file",
+    type=rc.Path(exists=True, dir_okay=False, path_type=Path),
+)
+@rc.argument("icon_names", nargs=-1, required=True, metavar="ICON_NAMES...")
+@rc.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Enable verbose debug logging.",
+)
+@rc.option(
+    "--quiet",
+    "-q",
+    is_flag=True,
+    help="Suppress all output except errors.",
+)
+def remove(
+    library_file: Path,
+    icon_names: tuple[str, ...],
+    verbose: bool,
+    quiet: bool,
+) -> None:
+    """Remove icons from a DrawIO library by name.
+
+    Removes one or more icons from an existing library file.
+
+    Examples:
+        Remove single icon:
+        $ SVG2DrawIOLib remove my-library.xml old-icon
+
+
+        Remove multiple icons:
+        $ SVG2DrawIOLib remove my-library.xml icon1 icon2 icon3
+    """
+    setup_logging(verbose, quiet)
+    logger = logging.getLogger(__name__)
+
+    try:
+        manager = LibraryManager()
+        metadata, removed_count = manager.remove_icons_from_library(library_file, list(icon_names))
+
+        if removed_count == 0:
+            console.print(
+                "[yellow]Warning:[/yellow] No icons were removed. "
+                "Requested icons not found in library."
+            )
+        else:
+            console.print(
+                f"[green]✓[/green] Removed {removed_count} icon(s). "
+                f"Library now has {metadata.icon_count} icon(s): [cyan]{library_file}[/cyan]"
+            )
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        if verbose:
+            raise
+        sys.exit(1)

SVG2DrawIOLib/library_manager.py

@@ -0,0 +1,269 @@
+"""DrawIO library management functionality."""
+
+import json
+import logging
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+from SVG2DrawIOLib.models import DrawIOIcon, LibraryMetadata
+
+logger = logging.getLogger(__name__)
+
+
+class LibraryManager:
+    """Manages DrawIO library files."""
+
+    def __init__(self) -> None:
+        """Initialize the library manager."""
+        pass
+
+    def create_library(self, icons: list[DrawIOIcon], output_path: Path) -> LibraryMetadata:
+        """Create a new DrawIO library from icons.
+
+        Args:
+            icons: List of DrawIO icons to include.
+            output_path: Path where the library file will be saved.
+
+        Returns:
+            LibraryMetadata with information about the created library.
+        """
+        logger.info(f"Creating library with {len(icons)} icon(s)")
+
+        # Sort icons alphabetically by name
+        sorted_icons = sorted(icons, key=lambda icon: icon.name)
+
+        # Convert to library JSON format
+        library_data = [icon.to_dict() for icon in sorted_icons]
+        library_json = json.dumps(library_data)
+
+        # Create XML structure
+        mxlibrary = ET.Element("mxlibrary")
+        mxlibrary.text = library_json
+
+        tree = ET.ElementTree(mxlibrary)
+
+        # Write to file
+        tree.write(output_path, encoding="utf-8", xml_declaration=True)
+
+        logger.info(f"Library created successfully: {output_path}")
+
+        return LibraryMetadata(
+            name=output_path.stem,
+            icon_count=len(icons),
+            source_files=[],
+        )
+
+    def load_library(self, library_path: Path) -> list[DrawIOIcon]:
+        """Load icons from an existing DrawIO library.
+
+        Args:
+            library_path: Path to the library file.
+
+        Returns:
+            List of DrawIO icons from the library.
+
+        Raises:
+            FileNotFoundError: If the library file does not exist.
+            ValueError: If the library file is invalid.
+        """
+        if not library_path.exists():
+            logger.error(f"Library file not found: {library_path}")
+            raise FileNotFoundError(f"Library file not found: {library_path}")
+
+        logger.debug(f"Loading library: {library_path}")
+
+        try:
+            tree = ET.parse(library_path)  # nosec B314 - User-provided library file, user controls input
+            root = tree.getroot()
+
+            if root.tag != "mxlibrary":
+                raise ValueError(
+                    f"Invalid library file: root element is {root.tag}, expected mxlibrary"
+                )
+
+            if not root.text:
+                logger.warning("Library file is empty")
+                return []
+
+            library_data = json.loads(root.text)
+
+            icons = []
+            for item in library_data:
+                # Convert from library format back to DrawIOIcon
+                # Note: We need to re-encode the XML data
+                from SVG2DrawIOLib.models import SVGDimensions
+
+                icon = DrawIOIcon(
+                    name=item["title"],
+                    xml_data=item["xml"].encode("ascii"),
+                    dimensions=SVGDimensions(width=item["w"], height=item["h"]),
+                )
+                icons.append(icon)
+
+            logger.info(f"Loaded {len(icons)} icon(s) from library")
+            return icons
+
+        except ET.ParseError as e:
+            logger.error(f"Failed to parse library file: {e}")
+            raise ValueError(f"Invalid library file: {e}") from e
+        except (json.JSONDecodeError, KeyError) as e:
+            logger.error(f"Invalid library format: {e}")
+            raise ValueError(f"Invalid library format: {e}") from e
+
+    def add_icons_to_library(
+        self,
+        library_path: Path,
+        new_icons: list[DrawIOIcon],
+        replace_duplicates: bool = False,
+        add_duplicates: bool = False,
+    ) -> LibraryMetadata:
+        """Add icons to an existing library.
+
+        Args:
+            library_path: Path to the existing library file.
+            new_icons: List of icons to add.
+            replace_duplicates: If True, replace icons with duplicate names.
+            add_duplicates: If True, add duplicates with modified names (e.g., icon_2, icon_3).
+
+        Returns:
+            LibraryMetadata with updated library information.
+
+        Raises:
+            FileNotFoundError: If the library file does not exist.
+            ValueError: If the library file is invalid.
+        """
+        logger.info(f"Adding {len(new_icons)} icon(s) to library: {library_path}")
+
+        # Load existing icons
+        existing_icons = self.load_library(library_path)
+
+        # Check for duplicate names in existing icons and make them unique
+        existing_names = [icon.name for icon in existing_icons]
+        if len(existing_names) != len(set(existing_names)):
+            # Find duplicates and rename them
+            name_counts: dict[str, int] = {}
+            renamed_count = 0
+
+            for i, icon in enumerate(existing_icons):
+                if icon.name in name_counts:
+                    # This is a duplicate - create unique name
+                    name_counts[icon.name] += 1
+                    counter = name_counts[icon.name]
+                    new_name = f"{icon.name}_{counter}"
+
+                    # Ensure the new name is also unique
+                    while new_name in existing_names or new_name in name_counts:
+                        counter += 1
+                        new_name = f"{icon.name}_{counter}"
+
+                    # Update name_counts to reflect the actual counter used
+                    name_counts[icon.name] = counter
+
+                    # Create new icon with unique name
+                    existing_icons[i] = DrawIOIcon(
+                        name=new_name,
+                        xml_data=icon.xml_data,
+                        dimensions=icon.dimensions,
+                    )
+                    renamed_count += 1
+                    logger.debug(f"Renamed duplicate icon: {icon.name} -> {new_name}")
+                else:
+                    name_counts[icon.name] = 1
+
+            logger.info(
+                f"Renamed {renamed_count} duplicate icon(s) to preserve all icons from library"
+            )
+
+        # Create a map of existing icons by name (now all unique)
+        icon_map = {icon.name: icon for icon in existing_icons}
+
+        # Add or replace icons
+        added_count = 0
+        replaced_count = 0
+        skipped_count = 0
+
+        for new_icon in new_icons:
+            if new_icon.name in icon_map:
+                if replace_duplicates:
+                    icon_map[new_icon.name] = new_icon
+                    replaced_count += 1
+                    logger.debug(f"Replaced icon: {new_icon.name}")
+                elif add_duplicates:
+                    # Find a unique name by appending _2, _3, etc.
+                    base_name = new_icon.name
+                    counter = 2
+                    unique_name = f"{base_name}_{counter}"
+                    while unique_name in icon_map:
+                        counter += 1
+                        unique_name = f"{base_name}_{counter}"
+
+                    # Create new icon with unique name
+                    unique_icon = DrawIOIcon(
+                        name=unique_name,
+                        xml_data=new_icon.xml_data,
+                        dimensions=new_icon.dimensions,
+                    )
+                    icon_map[unique_name] = unique_icon
+                    added_count += 1
+                    logger.debug(f"Added duplicate icon with modified name: {unique_name}")
+                else:
+                    skipped_count += 1
+                    logger.debug(f"Skipped duplicate icon: {new_icon.name}")
+            else:
+                icon_map[new_icon.name] = new_icon
+                added_count += 1
+                logger.debug(f"Added icon: {new_icon.name}")
+
+        logger.info(f"Added: {added_count}, Replaced: {replaced_count}, Skipped: {skipped_count}")
+
+        # Save updated library
+        all_icons = list(icon_map.values())
+        return self.create_library(all_icons, library_path)
+
+    def remove_icons_from_library(
+        self, library_path: Path, icon_names: list[str]
+    ) -> tuple[LibraryMetadata, int]:
+        """Remove icons from a library by name.
+
+        Args:
+            library_path: Path to the library file.
+            icon_names: List of icon names to remove.
+
+        Returns:
+            Tuple of (LibraryMetadata with updated library information, number of icons actually removed).
+
+        Raises:
+            FileNotFoundError: If the library file does not exist.
+            ValueError: If the library file is invalid.
+        """
+        logger.info(f"Removing {len(icon_names)} icon(s) from library: {library_path}")
+
+        # Load existing icons
+        existing_icons = self.load_library(library_path)
+
+        # Filter out icons to remove
+        names_to_remove = set(icon_names)
+        filtered_icons = [icon for icon in existing_icons if icon.name not in names_to_remove]
+
+        removed_count = len(existing_icons) - len(filtered_icons)
+        logger.info(f"Removed {removed_count} icon(s)")
+
+        # Save updated library
+        metadata = self.create_library(filtered_icons, library_path)
+        return metadata, removed_count
+
+    def list_icons(self, library_path: Path) -> list[str]:
+        """List all icon names in a library.
+
+        Args:
+            library_path: Path to the library file.
+
+        Returns:
+            List of icon names.
+
+        Raises:
+            FileNotFoundError: If the library file does not exist.
+            ValueError: If the library file is invalid.
+        """
+        icons = self.load_library(library_path)
+        return [icon.name for icon in icons]

SVG2DrawIOLib/models.py

@@ -0,0 +1,129 @@
+"""Data models for SVG to DrawIO conversion."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class SVGDimensions:
+    """Dimensions for an SVG shape in DrawIO.
+
+    Attributes:
+        width: Width in pixels.
+        height: Height in pixels.
+    """
+
+    width: float
+    height: float
+
+    @classmethod
+    def from_max_dimension(cls, max_dimension: float, aspect_ratio: float) -> "SVGDimensions":
+        """Create dimensions from a maximum dimension and aspect ratio.
+
+        Scales dimensions so the longest side equals max_dimension while
+        maintaining the aspect ratio.
+
+        Args:
+            max_dimension: Maximum dimension (width or height) in pixels.
+            aspect_ratio: Width/height ratio.
+
+        Returns:
+            SVGDimensions with scaled width and height.
+
+        Example:
+            >>> # For a 100x50 image with max_dimension=40
+            >>> dims = SVGDimensions.from_max_dimension(40, 2.0)
+            >>> dims.width, dims.height
+            (40.0, 20.0)
+        """
+        if aspect_ratio >= 1.0:
+            # Width is longer
+            return cls(width=max_dimension, height=max_dimension / aspect_ratio)
+        else:
+            # Height is longer
+            return cls(width=max_dimension * aspect_ratio, height=max_dimension)
+
+    @classmethod
+    def from_fixed_dimensions(cls, width: float, height: float) -> "SVGDimensions":
+        """Create dimensions from fixed width and height.
+
+        Args:
+            width: Width in pixels.
+            height: Height in pixels.
+
+        Returns:
+            SVGDimensions with specified dimensions.
+        """
+        return cls(width=width, height=height)
+
+
+@dataclass
+class DrawIOIcon:
+    """Represents a single icon in a DrawIO library.
+
+    Attributes:
+        name: Icon name (typically filename without extension).
+        xml_data: Compressed and encoded XML data.
+        dimensions: Icon dimensions.
+    """
+
+    name: str
+    xml_data: bytes
+    dimensions: SVGDimensions
+
+    def to_dict(self) -> dict[str, str | int | float]:
+        """Convert to DrawIO library JSON format.
+
+        Returns:
+            Dictionary with DrawIO library format fields.
+        """
+        return {
+            "xml": self.xml_data.decode("ascii"),
+            "w": int(self.dimensions.width),
+            "h": int(self.dimensions.height),
+            "aspect": "fixed",
+            "title": self.name,
+        }
+
+
+@dataclass
+class SVGProcessingOptions:
+    """Options for processing SVG files.
+
+    Attributes:
+        add_css: Whether to add CSS classes for color editing.
+        css_color: Default CSS fill color.
+        xml_namespace: XML namespace for SVG elements.
+        css_tag: XML tag to add CSS classes to.
+    """
+
+    add_css: bool = False
+    css_color: str = "#000000"
+    xml_namespace: str = "http://www.w3.org/2000/svg"
+    css_tag: str = "path"
+
+    @property
+    def namespaced_tag(self) -> str:
+        """Get the CSS tag with namespace prefix.
+
+        Returns:
+            Tag name with namespace in Clark notation.
+        """
+        if self.xml_namespace:
+            return f"{{{self.xml_namespace}}}{self.css_tag}"
+        return self.css_tag
+
+
+@dataclass
+class LibraryMetadata:
+    """Metadata for a DrawIO library.
+
+    Attributes:
+        name: Library name.
+        icon_count: Number of icons in the library.
+        source_files: List of source SVG files.
+    """
+
+    name: str
+    icon_count: int
+    source_files: list[Path] = field(default_factory=list)