Add Library Schema, Helpers, and Metadata

Author: TShapinsky

buildingmotif/bin/cli.py

@@ -6,13 +6,15 @@
 from pathlib import Path
 
 from buildingmotif import BuildingMOTIF
+from buildingmotif.bin.library import add_commands
 from buildingmotif.dataclasses import Library
 from buildingmotif.ingresses.bacnet import BACnetNetwork
 
 cli = argparse.ArgumentParser(
     prog="buildingmotif", description="CLI Interface for common BuildingMOTIF tasks"
 )
 subparsers = cli.add_subparsers(dest="subcommand")
+
 subcommands = {}
 log = logging.getLogger()
 log.setLevel(logging.INFO)
@@ -39,6 +41,22 @@ def decorator(func):
     return decorator
 
 
+def subparser(*subparser_args, parent=subparsers):
+    """Decorates a function and makes it available as a subparser"""
+
+    def decorator(func):
+        subcommand(*subparser_args, parent=parent)(func)
+
+        subparser = subcommands[func].add_subparsers(dest=f"{func.__name__}_subcommand")
+
+        def subcommand_decorator(*subparser_args, parent=subparser):
+            return subcommand(*subparser_args, parent=parent)
+
+        return subcommand_decorator
+
+    return decorator
+
+
 def get_db_uri(args) -> str:
     """
     Fetches the db uri from args, or prints the usage
@@ -163,6 +181,13 @@ def scan(args):
     bacnet_network.dump(Path(args.output_file))
 
 
+@subparser()
+def library(args):
+    """A collection of commands for working with libraries"""
+
+
+add_commands(library)
+
 # entrypoint is actually defined in pyproject.toml; this is here for convenience/testing
 if __name__ == "__main__":
     app()

buildingmotif/bin/cli_helpers.py

@@ -0,0 +1,158 @@
+from enum import Enum
+from typing import Union
+
+from pygit2.config import Config
+
+
+class Color(Enum):
+    """ANSI color codes for terminal text formatting.
+
+    Usage:
+    Color.GREEN("Example text"), produces green text.
+    Color.GREEN + "Example text" + Color.RESET, is the same as Color.GREEN("Example text")
+    """
+
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    LIGHT_GRAY = "\033[37m"
+    GRAY = "\033[90m"
+    LIGHT_RED = "\033[91m"
+    LIGHT_GREEN = "\033[92m"
+    LIGHT_YELLOW = "\033[93m"
+    LIGHT_BLUE = "\033[94m"
+    LIGHT_MAGENTA = "\033[95m"
+    LIGHT_CYAN = "\033[96m"
+    WHITE = "\033[97m"
+    RESET = "\033[0m"
+
+    def __call__(self, text):
+        return f"{self.value}{text}{Color.RESET.value}"
+
+    def __str__(self):
+        return self.value
+
+
+def print_tree(
+    tree: dict[Union[str, tuple[str, str]], Union[dict, None]], indent=4
+) -> None:
+    """Print a tree like dict to the console."""
+
+    def _tree_to_str(
+        item: Union[str, tuple[str, str]],
+        tree: Union[dict, None] = None,
+        level: int = 0,
+        indent: int = 4,
+    ) -> str:
+        """"""
+        description = ""
+        if isinstance(item, tuple):
+            name, description = item
+        else:
+            name = item
+
+        if level % 5 == 0:
+            name = Color.BLUE(name)
+        elif level % 5 == 1:
+            name = Color.MAGENTA(name)
+        elif level % 5 == 2:
+            name = Color.GREEN(name)
+        elif level % 5 == 3:
+            name = Color.CYAN(name)
+        elif level % 5 == 4:
+            name = Color.RED(name)
+
+        title = f"{name} {description}".strip()
+
+        lines = [title]
+        if tree is None:
+            return title
+        for index, (subitem, subtree) in enumerate(tree.items()):
+            subtree_lines = _tree_to_str(subitem, subtree, level + 1, indent).split(
+                "\n"
+            )
+            last = index == len(tree) - 1
+
+            for line_index, line in enumerate(subtree_lines):
+                prefix = " " * indent
+                if last:
+                    if line_index == 0:
+                        prefix = f"└{'─' * (indent - 2)} "
+                else:
+                    if line_index == 0:
+                        prefix = f"├{'─' * (indent - 2)} "
+                    else:
+                        prefix = f"│{' ' * (indent - 2)} "
+                subtree_lines[line_index] = f"{prefix}{line}"
+            lines.extend(subtree_lines)
+        return "\n".join(lines)
+
+    lines = []
+    for subitem, subtree in tree.items():
+        lines.append(_tree_to_str(subitem, subtree, 0, indent))
+    print("\n".join(lines))
+
+
+def get_input(
+    prompt: str,
+    default: Union[str, None] = None,
+    optional: bool = False,
+    input_type: Union[type] = str,
+) -> str | int | float | bool | None:
+    """
+    Helper function to get input from the user with a prompt.
+    If default is provided, it will be used if the user just presses Enter.
+    If optional is False, the user must provide an input.
+    """
+    parenthetical = f" [{Color.BLUE(default)}]" if default is not None else ""
+    if optional and default is not None:
+        parenthetical = f" [{Color.BLUE(default)}, {Color.MAGENTA('n to skip')}]"
+
+    if input_type is bool:
+        parenthetical = f"{parenthetical} {Color.MAGENTA('(y/n)')}"
+
+    while True:
+        user_input = input(f"{Color.GREEN(prompt)}{parenthetical}: ")
+        if not user_input:
+            if default is not None:
+                user_input = default
+            elif optional:
+                return None
+            else:
+                print("This field is required. Please provide a value.")
+                continue
+        try:
+            if user_input == "n" and optional:
+                return None
+            if input_type in [int, float, str]:
+                return input_type(user_input)
+            elif input_type is bool:
+                true_input = user_input.lower() in ["true", "1", "yes", "y"]
+                false_input = user_input.lower() in ["false", "0", "no", "n"]
+                if true_input:
+                    return True
+                elif false_input:
+                    return False
+                raise ValueError(f"Invalid input for boolean: {user_input}")
+            return input_type(user_input)
+        except ValueError:
+            print(
+                f"{Color.RED}Invalid input. Please enter a valid {input_type.__name__}.{Color.RESET}"
+            )
+
+
+def git_global_config() -> dict[str, str]:
+    """
+    Fetches the global git configuration.
+    """
+    config = Config.get_global_config()
+    return {value.name: value.value for value in config}
+
+
+def arg(*argnames, **kwargs):
+    """Helper for defining arguments on subcommands"""
+    return argnames, kwargs

buildingmotif/bin/library.py

@@ -0,0 +1,151 @@
+from pathlib import Path
+
+from jinja2 import Environment
+
+from buildingmotif import BuildingMOTIF
+from buildingmotif.bin.cli_helpers import (
+    Color,
+    arg,
+    get_input,
+    git_global_config,
+    print_tree,
+)
+from buildingmotif.dataclasses.library import Library
+from buildingmotif.dataclasses.shape_collection import find_imports
+
+
+def add_commands(library):
+    @library(
+        arg("path", help="Path to the library directory"),
+    )
+    def init(args):
+        """Initialize a library"""
+        library_path = Path(args.path).resolve()
+
+        template_file = (
+            Path(__file__).resolve().parents[1] / "resources" / "library.template.yml"
+        )
+
+        user_name = git_global_config().get("user.name")
+        user_email = git_global_config().get("user.email")
+        default_user = None
+        if user_name and user_email:
+            default_user = f"{user_name} <{user_email}>"
+
+        env = Environment()
+        template = env.from_string(template_file.read_text())
+
+        repeat = True
+
+        library_arguments = {}
+        while repeat:
+            print(
+                f"\n{Color.CYAN}This command will guide you through creating your {Color.GREEN}library.yaml{Color.CYAN} file.{Color.RESET}\n"
+            )
+
+            library_arguments["name"] = get_input(
+                "Library name",
+                default=library_arguments.get("name", library_path.name),
+                input_type=str,
+            )
+            library_arguments["version"] = get_input(
+                "Version",
+                default=library_arguments.get("version", "0.1.0"),
+                input_type=str,
+            )
+            library_arguments["description"] = get_input(
+                "Description",
+                default=library_arguments.get("description", ""),
+                input_type=str,
+            )
+            library_arguments["author"] = get_input(
+                "Author",
+                default=library_arguments.get("author", default_user),
+                optional=True,
+                input_type=str,
+            )
+            library_arguments["home"] = get_input(
+                "Home page URL",
+                default=library_arguments.get("home", None),
+                optional=True,
+                input_type=str,
+            )
+
+            print(
+                f"\n{Color.CYAN}Please confirm that the following information is correct:{Color.RESET}\n"
+            )
+            print(
+                f"{Color.GREEN}Name: {Color.BLUE}{library_arguments['name']}{Color.RESET}"
+            )
+            print(
+                f"{Color.GREEN}Version: {Color.BLUE}{library_arguments['version']}{Color.RESET}"
+            )
+            print(
+                f"{Color.GREEN}Description: {Color.BLUE}{library_arguments['description']}{Color.RESET}"
+            )
+            print(
+                f"{Color.GREEN}Author: {Color.BLUE}{library_arguments.get('author', '') or ''}{Color.RESET}"
+            )
+            print(
+                f"{Color.GREEN}Home page: {Color.BLUE}{library_arguments.get('home', '') or ''}{Color.RESET}"
+            )
+            print("\n")
+            confirm = get_input(
+                "Is this information correct?", default="y", input_type=bool
+            )
+            repeat = not confirm
+            print("\n")
+
+        library_path.mkdir(parents=True, exist_ok=True)
+        library_file = library_path / "library.yml"
+        if library_file.exists():
+            overwrite = get_input(
+                f"Library file '{library_file}' already exists. Overwrite?",
+                default="n",
+                input_type=bool,
+            )
+            if not overwrite:
+                print(f"{Color.RED}Library initialization aborted.{Color.RESET}")
+                return
+        library_file.write_text(template.render(library_arguments))
+
+    @library(
+        arg("path", help="Path to the library directory"),
+    )
+    def load(args):
+        """Load a library"""
+        BuildingMOTIF("sqlite:///").setup_tables()
+        # library_path = Path(args.path).resolve()
+        Library.load(directory=args.path)
+
+    @library(
+        arg("path", help="Path to the library directory"),
+        arg("--depth", help="Depth of the audit", type=int, default=3),
+    )
+    def audit(args):
+        """Generate an audit report of a library's dependencies"""
+
+        print("Setting up empty BuildingMOTIF")
+        BuildingMOTIF("sqlite:///").setup_tables()
+        print("\nLoading Library")
+        library = Library.load(
+            directory=args.path, run_shacl_inference=False, infer_templates=False
+        )
+        print("\nResolving Imports")
+        imports = find_imports(library.get_shape_collection().graph, depth=args.depth)
+
+        def imports_to_tree(imports):
+            tree = {}
+            for name, ((graph, source), imp) in imports.items():
+                description = Color.RED("Not Found")
+                if source == "library":
+                    description = Color.GREEN("Found in library")
+                elif source == "shape_collection":
+                    description = Color.GREEN("Found in shape collection")
+                elif source == "internet":
+                    description = Color.GREEN("Found on the internet")
+                item = (name, f" - {description}")
+                tree[item] = imports_to_tree(imp)
+            return tree
+
+        print_tree(imports_to_tree(imports))