st-creator 0.2.0__py3-none-any.whl

st_creator/__init__.py

@@ -0,0 +1,16 @@
+import click
+
+from st.commands.theme import theme
+from st.commands.version import version
+
+
+@click.group()
+def main():
+    """ST: A command line tool for creating Structurizr themes easily."""
+
+
+main.add_command(version)
+main.add_command(theme)
+
+if __name__ == "__main__":
+    main()

st_creator/commands/theme.py

@@ -0,0 +1,137 @@
+import os
+import pathlib
+
+import click
+
+from st.core.model import Theme
+from st.core.model import ThemeElement
+from st.core.model import go_through_fs_tree
+from st.core.rule_parser import RuleSet
+from st.core.rule_parser import filter_elements
+from st.utils.config import CONFIG_FILE
+from st.utils.config import init_config
+from st.utils.config import load_config
+from st.utils.pretty_print import print_done
+from st.utils.pretty_print import print_verbose
+from st.utils.pretty_print import print_warning
+from st.utils.str_utils import to_clean_string
+
+
+@click.group()
+def theme():
+    """Create a DSL theme."""
+
+
+@theme.command()
+@click.argument("path", type=click.Path(exists=True))
+@click.option("--output", type=click.Path(), required=False, default=None)
+@click.option(
+    "--rules",
+    type=click.Path(exists=True, dir_okay=False),
+    required=False,
+    default=None,
+    help="Path to a rules file (e.g. rules.st) filtering which icons to process.",
+)
+def clean(path, output, rules):
+    """Prepare a directory of icons for theme creation."""
+    full_path = pathlib.Path(path)
+    output_path = full_path.parent / (output if output else "cleaned")
+    if not output_path.exists():
+        output_path.mkdir(parents=True, exist_ok=True)
+    first_level = [item for item in os.listdir(full_path) if not item.startswith(".")]
+    first_level_dict = {item: to_clean_string(item) for item in first_level}
+    for item in first_level_dict.values():
+        if item.startswith("."):
+            print_verbose(f"Skipping hidden directory: {item}")
+        else:
+            if item is not None:
+                os.makedirs(os.path.join(output_path, item), exist_ok=True)
+    elements = go_through_fs_tree(
+        full_path=full_path, include_top_parent_directory=False
+    )
+    if rules is not None:
+        elements = filter_elements(elements, RuleSet.from_file(pathlib.Path(rules)))
+    for element in elements:
+        element.copy(
+            output_path=output_path
+            / element.top_parent_directory
+            / element.cleaned_file_name
+            if element.top_parent_directory
+            else output_path / element.cleaned_file_name
+        )
+    print_done("Cleaning done!")
+
+
+@theme.command()
+@click.argument("path", type=click.Path(exists=True))
+@click.option("--name", type=str, required=True)
+@click.option("--description", type=str, required=False, default=None)
+@click.option(
+    "--rules",
+    type=click.Path(exists=True, dir_okay=False),
+    required=False,
+    default=None,
+    help="Path to a rules file (e.g. rules.st) filtering which icons to process.",
+)
+def create(path, name: str, description: str | None, rules: str) -> None:
+    if not CONFIG_FILE.exists():
+        print_warning("Configuration file not found. Creating one with default values.")
+        init_config(config_path=CONFIG_FILE)
+    config = load_config(config_path=CONFIG_FILE)
+    full_path = pathlib.Path(path).resolve()
+    output_path = full_path.parent / "-".join(name.lower().split(" "))
+
+    name = name.replace("'", "").replace('"', "")
+    description = (
+        description.replace("'", "").replace('"', "")
+        if description is not None
+        else None
+    )
+    os.makedirs(os.path.join(output_path), exist_ok=True)
+    theme = Theme(
+        name="Name here" if name is None else name,
+        description="Description here" if description is None else description,
+    )
+
+    elements = go_through_fs_tree(
+        full_path=full_path,
+        include_top_parent_directory=False,
+    )
+    if rules is not None:
+        elements = filter_elements(elements, RuleSet.from_file(pathlib.Path(rules)))
+
+    for element in elements:
+        element.copy(
+            output_path=output_path / (theme.file_prefix + "_" + element.theme_name),
+        )
+        element.load_properties_from_json()
+
+        theme_element = ThemeElement(
+            tag=element.get_theme_tag(prefix=theme.tag_prefix),
+            # stroke=color
+            # if color is not None
+            # else config["defaults.theme"]["stroke"],
+            # color=color if color is not None else config["defaults.theme"]["color"],
+            stroke="#232f3d",
+            color="#232f3d",
+            icon=theme.file_prefix + "_" + element.theme_name,
+        )
+        theme.add_element(theme_element)
+
+    theme.export(pathlib.Path(output_path) / "theme.json")
+
+    print_done("Theme created!")
+
+
+# TODO: keep this for future releases maybe >^.^<
+# @click.command()
+# @click.option("--output", type=click.Path(), required=True)
+# def scrape(output) -> None:
+#     print(f"Scraping icons from {TECH_ICON_URL}\n")
+#     time.sleep(1)
+#     if download_blob_image(
+#         base_url=TECH_ICON_URL, output_dir=pathlib.Path(output).resolve()
+#     ):
+#         print_done("\nAll images downloaded successfully!")
+#     else:
+#         print_warning("\nDownload failed")

st_creator/commands/version.py

@@ -0,0 +1,9 @@
+import click
+
+from st.utils.pretty_print import print_version
+
+
+@click.command()
+def version():
+    """Get CLI version."""
+    print_version()

st_creator/core/model.py

@@ -0,0 +1,355 @@
+import json
+import os
+import pathlib
+import shutil
+from typing import Any
+
+from st.core.theme_attributes import Border
+from st.core.theme_attributes import Shape
+from st.utils.pretty_print import print_ok
+from st.utils.pretty_print import print_verbose
+from st.utils.pretty_print import print_warning
+from st.utils.str_utils import from_snake_to_camel_case
+from st.utils.str_utils import to_clean_string
+
+
+class IconElement:
+    """Class representing a icon in the file system.
+
+    The entire CLI is based on the file system structure and the icons found.
+    This class is the starting point for DSL theme elements, as it represents
+    the icons found.
+    """
+
+    def __init__(self, path: pathlib.Path, include_top_parent_directory: bool = True):
+        """Initialize a IconElement instance."""
+        self.path = path
+        self._include_top_parent_directory = include_top_parent_directory
+        self.top_parent_directory = (
+            pathlib.Path(to_clean_string(path.parts[1]))
+            if len(path.parts) > 2
+            else None
+        )
+
+        self.metadata: dict[str, Any] = {}
+
+    @property
+    def name(self) -> str:
+        """Get the name of the icon element without the file extension.
+
+        Returns:
+            str: The name of the icon element without the file extension.
+        """
+        return self.path.stem
+
+    @property
+    def full_name(self) -> str:
+        """Get the full name of the icon element with the file extension.
+
+        Returns:
+            str: The full name of the icon element with the file extension.
+        """
+        return self.path.name
+
+    @property
+    def extension(self) -> str:
+        """Get the file extension of the icon element.
+
+        Returns:
+            str: The file extension of the icon element.
+        """
+        return self.path.suffix
+
+    @property
+    def cleaned_file_name(self) -> str:
+        """Get the output file path for the icon element.
+
+        Returns:
+            str: The output file path for the icon element.
+        """
+        if (
+            self.top_parent_directory is not None
+        ) and self._include_top_parent_directory:
+            return (
+                self.top_parent_directory.name
+                + "_"
+                + to_clean_string(self.name)
+                + self.extension
+            )
+        else:
+            return to_clean_string(self.name) + self.extension
+
+    @property
+    def theme_name(self) -> str:
+        theme_name = self.path.parent.parts[-1].split("_")[0].lower() + "_" + self.name
+        return theme_name + self.extension
+
+    def get_theme_tag(self, prefix: str | None = None) -> str:
+        theme_name = self.theme_name.split(".")[0]
+        tag_name = (
+            theme_name.split("_")[0].capitalize()
+            + " - "
+            + " ".join([word.capitalize() for word in theme_name.split("_")[1:]])
+        )
+        if prefix is not None:
+            tag_name = prefix + " - " + tag_name
+
+        return tag_name
+
+    # TODO: find a way to manage this logic in a more elegant way
+    def load_properties_from_json(self):
+        """Load propertiers from a JSON file located alongside the element SVG file.
+
+        Args:
+            path (str): Path to the JSON file containing metadata.
+        """
+        try:
+            json_file = self.path.resolve().stem + ".json"
+            json_file_path = self.path.parent / json_file
+
+            with open(json_file_path) as f:
+                self.metadata = json.load(f)
+                print_verbose(f"Loaded metadata for {self.name}")
+        except FileNotFoundError:
+            self.metadata = {}
+
+    def copy(
+        self,
+        output_path: pathlib.Path,
+    ):
+        """Copy the icon element to a new location.
+
+        This is particularly to correctly manage icons for the DSL theme.
+
+        Args:
+            output_path (pathlib.Path): The path to copy the icon element to.
+        """
+        shutil.copyfile(
+            self.path,
+            output_path,
+        )
+        print_ok("Processed " + self.full_name)
+
+    def __str__(self) -> str:
+        """Return a string representation of the IconElement instance.
+
+        Returns:
+            str: A string representation of the IconElement instance.
+        """
+        return f"Element(name={self.name}, path={self.path})"
+
+    def __repr__(self) -> str:
+        """Return a string representation of the IconElement instance.
+
+        Returns:
+            str: A string representation of the IconElement instance.
+        """
+        repr_str = "IconElement("
+        for key, value in self.__class__.__dict__.items():
+            if not key.startswith("__") and not callable(value):
+                repr_str += f"{key}={getattr(self, key)}, "
+        repr_str = repr_str.rstrip(", ") + ")"
+        return repr_str
+
+
+class ThemeElement:
+    """Class representing a theme element for the DSL theme."""
+
+    def __init__(
+        self,
+        tag: str | None = None,
+        stroke: str | None = None,
+        color: str | None = None,
+        icon: str | None = None,
+        border: Border | None = Border.SOLID,
+        shape: Shape | None = Shape.ROUDED_BOX,
+        width: int | None = None,
+        height: int | None = None,
+        background: str | None = None,
+        font_size: int | None = None,
+        opacity: int | None = None,
+        description: str | None = None,
+    ):
+        """Initialize a ThemeElement instance.
+
+        Args:
+            tag (str): The tag for the theme element.
+            stroke (str): The stroke color for the theme element.
+            color (str): The fill color for the theme element.
+            icon (str): The icon for the theme element.
+            shape (Shape): The shape of the theme element.
+            width (int): The width of the theme element.
+            height (int): The height of the theme element.
+            background (str): The background color for the theme element.
+            font_size (int): The font size for the theme element.
+            border (Border): The border style for the theme element.
+            opacity (int): The opacity for the theme element.
+            description (str): A brief description of the theme element.
+        """
+        self.tag = tag
+        self.stroke = stroke
+        self.color = color
+        self.icon = icon
+        self.shape = shape.value if shape is not None else None
+        self.width = width
+        self.height = height
+        self.background = background
+        self.font_size = font_size
+        self.border = border.value if border is not None else None
+        self.opacity = opacity
+        self.description = description
+
+    def as_dict(self) -> dict[str, Any]:
+        """Convert the ThemeElement instance to a dictionary. Skip None attribues.
+
+        Dictionary names are the final names used in the DSL theme.
+        To do so, snake_case attribute names are converted to camelCase.
+
+        Returns:
+            dict: A dictionary representation of the ThemeElement instance.
+        """
+        dict_representation = {}
+        # Iterate over class attributes
+        for attribute, value in self.__dict__.items():
+            if value is not None:
+                dict_representation[from_snake_to_camel_case(attribute)] = value
+        return dict_representation
+
+    @classmethod
+    def from_json_dict(cls, dict: dict[str, Any]) -> "ThemeElement":
+        """Create a ThemeElement instance from a dictionary.
+
+        Args:
+            dict (dict): A dictionary of the attributes of the ThemeElement.
+            As it is in the theme. Thus, the keys are in camelCase.
+
+        Returns:
+            ThemeElement: A new instance of ThemeElement.
+        """
+        theme_element = cls()
+        for key, value in dict.items():
+            if hasattr(theme_element, key) and key != "tag":
+                setattr(theme_element, key, value)
+            else:
+                print_warning(f"Unknown attribute {key} in ThemeElement JSON.")
+        return theme_element
+
+
+def get_tag_theme_prefix(theme_name: str) -> str:
+    """Get the prefix for a theme based on its name.
+
+    The prefix is generated by taking the first letter of each word in the theme name,
+    converted to a clean string, that originally had more than 3 characters.
+
+    Args:
+        theme_name (str): The name of the theme.
+
+    Returns:
+        str: The prefix for the theme.
+    """
+    eligible_words = [
+        to_clean_string(word) for word in theme_name.split() if len(word) > 2
+    ]
+    prefix = (
+        "".join([word[0].lower() for word in eligible_words])
+        if len(eligible_words) > 2
+        else to_clean_string(theme_name)
+    )
+    return prefix
+
+
+def get_file_theme_prefix(theme_name: str) -> str:
+    """Get the prefix for a theme based on its name.
+
+    The prefix is generated by taking the first letter of each word in the theme name,
+    converted to a clean string, that originally had more than 3 characters.
+
+    Args:
+        theme_name (str): The name of the theme.
+
+    Returns:
+        str: The prefix for the theme.
+    """
+    eligible_words = [
+        to_clean_string(word) for word in theme_name.split() if len(word) > 2
+    ]
+    prefix = (
+        "".join([word[0].lower() for word in eligible_words])
+        if len(eligible_words) > 2
+        else to_clean_string(theme_name)
+    )
+    return prefix
+
+
+class Theme:
+    """Class representing a theme, which is a collection of theme elements."""
+
+    def __init__(self, name: str, description: str):
+        """Initialize a Theme instance.
+
+        Args:
+            name (str): The name of the theme.
+            description (str): A brief description of the theme.
+        """
+        self.name = name
+        self.description = description
+        self.tag_prefix = get_tag_theme_prefix(name)
+        self.file_prefix = get_file_theme_prefix(name)
+        self.elements: list[ThemeElement] = []
+
+    def add_element(self, element: ThemeElement) -> None:
+        """Add a theme element to the theme.
+
+        Args:
+            element (ThemeElement): The theme element to add.
+        """
+        self.elements.append(element)
+
+    def extend(self, elements: list[ThemeElement]) -> None:
+        """Extend the theme with a list of theme elements.
+
+        Args:
+            elements (list[ThemeElement]): A list of theme elements to add.
+        """
+        self.elements.extend(elements)
+
+    def export(self, path: pathlib.Path) -> None:
+        """Export the theme to a JSON file.
+
+        Args:
+            path (pathlib.Path): The path to the JSON file.
+        """
+        json_dict = {
+            "name": self.name,
+            "description": self.description,
+            "elements": [element.as_dict() for element in self.elements],
+        }
+
+        with open(path, "w") as f:
+            json.dump(json_dict, f, indent=4)
+
+
+def go_through_fs_tree(
+    full_path: pathlib.Path,
+    include_top_parent_directory: bool,
+) -> list[IconElement]:
+    element_list = []
+    for item in os.listdir(full_path):
+        item_path = pathlib.Path(full_path) / item
+        if os.path.isfile(item_path):
+            if item.startswith("."):
+                print_verbose(
+                    f"Skipping hidden file: {'/'.join(str(item_path).split('/')[-3:])}"
+                )
+                continue
+            element_list.append(IconElement(item_path, include_top_parent_directory))
+
+        elif os.path.isdir(item_path):
+            element_list.extend(
+                go_through_fs_tree(
+                    full_path=item_path,
+                    include_top_parent_directory=include_top_parent_directory,
+                )
+            )
+
+    return element_list