vss-tools 0.5.0.dev0__py3-none-any.whl

vspec/vssexporters/vss2protobuf.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2021 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+# Convert vspec file to proto
+#
+
+import argparse
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Set
+from typing import Optional
+
+from anytree import PreOrderIter  # type: ignore[import]
+from vspec.model.vsstree import VSSNode
+from vspec.vss2x import Vss2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+
+# Add path to main py vspec  parser
+myDir = os.path.dirname(os.path.realpath(__file__))
+sys.path.append(os.path.join(myDir, ".."))
+
+PATH_DELIMITER = "."
+DIR_DELIMITER = "/"
+
+mapped = {
+    "uint16": "uint32",
+    "uint8": "uint32",
+    "int8": "int32",
+    "int16": "int32",
+    "boolean": "bool"
+}
+
+
+class ProtoExporter(object):
+    def __init__(self, out_dir: Path):
+        self.out_files: Set[Path] = set()
+        self.out_dir = out_dir
+
+    def setup_file(self, fp: Path, package_name: str):
+        with open(fp, 'w') as proto_file:
+            logging.info(f"Initializing {fp}, package {package_name}")
+            proto_file.write("syntax = \"proto3\";\n\n")
+            # set up the proto's package
+            proto_file.write(f"package {package_name};\n\n")
+            self.out_files.add(fp)
+
+    def traverse_data_type_tree(self, tree: VSSNode):
+        """
+        All structs in a branch are written to a single .proto file.
+        The file's base name is same as the branch's name
+        The fully qualified path of the type becomes the package.
+
+        Example A.B.C.MyType becomes:
+        "package A.B.C;
+        message MyType{}"
+
+        The files are organized by package.
+        With the above example, the file generated is
+        A/B/C/C.proto
+        """
+
+        tree_node: VSSNode
+
+        for tree_node in filter(lambda n: n.is_struct(), PreOrderIter(tree)):
+            type_qn = tree_node.qualified_name(PATH_DELIMITER).split(PATH_DELIMITER)
+            curr_branch_qn = type_qn[:-1]
+            # create dir if necessary
+            dp = self.out_dir / Path(DIR_DELIMITER.join(curr_branch_qn))
+            dp.mkdir(parents=True, exist_ok=True)
+
+            curr_branch = type_qn[-2]
+            fp = dp / Path(f'{curr_branch}.proto')
+            is_first_write = fp not in self.out_files
+            if is_first_write:
+                self.setup_file(fp, '.'.join(curr_branch_qn))
+            with open(fp, 'a') as proto_file:
+                # import of other proto types in other branches
+                imports = []
+                for c_node in filter(lambda c: c.is_property() and not c.has_datatype(), tree_node.children):
+                    child_branch_path = c_node.get_datatype().split(PATH_DELIMITER)[:-1]
+                    child_branch_path_str = DIR_DELIMITER.join(child_branch_path)
+                    if child_branch_path_str != DIR_DELIMITER.join(curr_branch_qn):
+                        child_basename = child_branch_path[-1]
+                        imports.append(f"{child_branch_path_str}/{child_basename}.proto")
+
+                # unique sorted list
+                imports = list(set(imports))
+                imports.sort()
+                for importstmt in imports:
+                    proto_file.write(f"import \"{importstmt}\";\n")
+                proto_file.write("\n")
+
+                proto_file.write(f"message {type_qn[-1]} {{" + "\n")
+                print_message_body(tree_node.children, proto_file)
+                proto_file.write("}\n\n")
+                logging.info(f"Wrote {type_qn[-1]} to {fp}")
+
+
+def traverse_signal_tree(tree: VSSNode, proto_file):
+    proto_file.write("syntax = \"proto3\";\n\n")
+    tree_node: VSSNode
+
+    # get all the import statements for dependent types (structs)
+    imports = []
+    for c_node in filter(lambda c: c.is_signal() and not c.has_datatype(), PreOrderIter(tree)):
+        child_path = c_node.get_datatype().split(PATH_DELIMITER)[:-1]
+        child_basename = child_path[-1]
+        imports.append(f"{DIR_DELIMITER.join(child_path)}/{child_basename}.proto")
+
+    # unique sorted list
+    imports = list(set(imports))
+    imports.sort()
+    # write import statements to file
+    for importstmt in imports:
+        proto_file.write(f"import \"{importstmt}\";\n")
+    proto_file.write("\n")
+
+    # write proto messages to file
+    for tree_node in filter(lambda n: n.is_branch(), PreOrderIter(tree)):
+        proto_file.write(f"message {tree_node.qualified_name('')} {{" + "\n")
+        print_message_body(tree_node.children, proto_file)
+        proto_file.write("}\n\n")
+
+
+def print_message_body(nodes, proto_file):
+    for i, node in enumerate(nodes, 1):
+        data_type = node.qualified_name("")
+        if not (node.is_branch() or node.is_struct()):
+            dt_val = node.get_datatype()
+            data_type = mapped.get(dt_val.strip("[]"), dt_val.strip("[]"))
+            data_type = ("repeated " if dt_val.endswith("[]") else "") + data_type
+        proto_file.write(f"  {data_type} {node.name} = {i};" + "\n")
+
+
+class Vss2Protobuf(Vss2X):
+
+    def __init__(self, vspec2vss_config: Vspec2VssConfig):
+        vspec2vss_config.no_expand_option_supported = False
+        vspec2vss_config.uuid_supported = False
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('--json-all-extended-attributes', action='store_true',
+                            help="Generate all extended attributes found in the model "
+                                 "(default is generating only those given by the -e/--extended-attributes parameter).")
+        parser.add_argument('--json-pretty', action='store_true',
+                            help=" Pretty print JSON output.")
+
+    def generate(self, config: argparse.Namespace, signal_root: VSSNode, vspec2vss_config: Vspec2VssConfig,
+                 data_type_root: Optional[VSSNode] = None) -> None:
+        logging.info("Generating protobuf output...")
+        if data_type_root is not None:
+            if config.types_output_file is not None:
+                fp = Path(config.types_output_file)
+                exporter_path = Path(os.path.dirname(fp))
+            else:
+                exporter_path = Path(Path.cwd())
+            logging.debug(f"Will use {exporter_path} for type exports")
+            exporter = ProtoExporter(exporter_path)
+            exporter.traverse_data_type_tree(data_type_root)
+
+        with open(config.output_file, 'w') as f:
+            traverse_signal_tree(signal_root, f)

vspec/vssexporters/vss2yaml.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2016 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert all vspec input files to a single flat YAML file.
+#
+
+
+import argparse
+from vspec.model.vsstree import VSSNode
+import yaml
+import logging
+from typing import Dict, Any
+from typing import Optional
+from vspec.vss2x import Vss2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+
+
+def export_node(yaml_dict, node, config, print_uuid):
+
+    node_path = node.qualified_name()
+
+    yaml_dict[node_path] = {}
+
+    yaml_dict[node_path]["type"] = str(node.type.value)
+
+    if node.is_signal() or node.is_property():
+        yaml_dict[node_path]["datatype"] = node.get_datatype()
+
+    # many optional attributes are initilized to "" in vsstree.py
+    if node.min != "":
+        yaml_dict[node_path]["min"] = node.min
+    if node.max != "":
+        yaml_dict[node_path]["max"] = node.max
+    if node.allowed != "":
+        yaml_dict[node_path]["allowed"] = node.allowed
+    if node.default != "":
+        yaml_dict[node_path]["default"] = node.default
+    if node.deprecation != "":
+        yaml_dict[node_path]["deprecation"] = node.deprecation
+
+    # in case of unit or aggregate, the attribute will be missing
+    try:
+        yaml_dict[node_path]["unit"] = str(node.unit.value)
+    except AttributeError:
+        pass
+    try:
+        yaml_dict[node_path]["aggregate"] = node.aggregate
+    except AttributeError:
+        pass
+
+    yaml_dict[node_path]["description"] = node.description
+
+    if node.comment != "":
+        yaml_dict[node_path]["comment"] = node.comment
+
+    if print_uuid:
+        yaml_dict[node_path]["uuid"] = node.uuid
+
+    for k, v in node.extended_attributes.items():
+        if not config.yaml_all_extended_attributes and k not in VSSNode.whitelisted_extended_attributes:
+            continue
+        yaml_dict[node_path][k] = v
+
+    # Include instance information if we run tool in "no-expand" mode
+    if config.no_expand and node.instances is not None:
+        yaml_dict[node_path]["instances"] = node.instances
+
+    for child in node.children:
+        export_node(yaml_dict, child, config, print_uuid)
+
+
+def export_yaml(file_name, content_dict):
+    with open(file_name, 'w') as f:
+        yaml.dump(content_dict, f, default_flow_style=False, Dumper=NoAliasDumper,
+                  sort_keys=True, width=1024, indent=2, encoding='utf-8', allow_unicode=True)
+
+
+# create dumper to remove aliases from output and to add nice new line after each object for a better readability
+class NoAliasDumper(yaml.SafeDumper):
+    def ignore_aliases(self, data):
+        return True
+
+    def write_line_break(self, data=None):
+        super().write_line_break(data)
+        if len(self.indents) == 1:
+            super().write_line_break()
+
+
+class Vss2Yaml(Vss2X):
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument('--yaml-all-extended-attributes', action='store_true',
+                            help=("Generate all extended attributes found in the model "
+                                  "(default is generating only those given by the "
+                                  "-e/--extended-attributes parameter)."))
+
+    def generate(self, config: argparse.Namespace, signal_root: VSSNode, vspec2vss_config: Vspec2VssConfig,
+                 data_type_root: Optional[VSSNode] = None) -> None:
+
+        logging.info("Generating YAML output...")
+
+        signals_yaml_dict: Dict[str, Any] = {}
+        export_node(signals_yaml_dict, signal_root, config, vspec2vss_config.generate_uuid)
+
+        if data_type_root is not None:
+            data_types_yaml_dict: Dict[str, Any] = {}
+            export_node(data_types_yaml_dict, data_type_root, config, vspec2vss_config.generate_uuid)
+            if config.types_output_file is None:
+                logging.info("Adding custom data types to signal dictionary")
+                signals_yaml_dict["ComplexDataTypes"] = data_types_yaml_dict
+            else:
+                export_yaml(config.types_output_file, data_types_yaml_dict)
+
+        export_yaml(config.output_file, signals_yaml_dict)

vss_tools-0.5.0.dev0.data/scripts/vspec2csv.py

@@ -0,0 +1,29 @@
+#!python
+#
+# Copyright (c) 2016 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert vspec2csv wrapper for vspec2x
+#
+
+import sys
+from vspec.vspec2x import Vspec2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+from vspec.vssexporters.vss2csv import Vss2Csv
+
+
+def main(args):
+    vspec2vss_config = Vspec2VssConfig()
+    vss2csv = Vss2Csv()
+    vspec2x = Vspec2X(vss2csv, vspec2vss_config)
+    vspec2x.main(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

vss_tools-0.5.0.dev0.data/scripts/vspec2ddsidl.py

@@ -0,0 +1,29 @@
+#!python
+#
+# Copyright (c) 2022 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert vspec2idl wrapper for vspec2x
+#
+
+import sys
+from vspec.vspec2x import Vspec2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+from vspec.vssexporters.vss2ddsidl import Vss2DdsIdl
+
+
+def main(args):
+    vspec2vss_config = Vspec2VssConfig()
+    vss2json = Vss2DdsIdl(vspec2vss_config)
+    vspec2x = Vspec2X(vss2json, vspec2vss_config)
+    vspec2x.main(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

vss_tools-0.5.0.dev0.data/scripts/vspec2franca.py

@@ -0,0 +1,29 @@
+#!python
+
+# Copyright (c) 2016 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert vspec file to FrancaIDL spec.
+#
+
+import sys
+from vspec.vspec2x import Vspec2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+from vspec.vssexporters.vss2franca import Vss2Franca
+
+
+def main(args):
+    vspec2vss_config = Vspec2VssConfig()
+    vss2franca = Vss2Franca(vspec2vss_config)
+    vspec2x = Vspec2X(vss2franca, vspec2vss_config)
+    vspec2x.main(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

vss_tools-0.5.0.dev0.data/scripts/vspec2graphql.py

@@ -0,0 +1,29 @@
+#!python
+#
+# Copyright (c) 2022 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert vspec2grahql wrapper for vspec2x
+#
+
+import sys
+from vspec.vspec2x import Vspec2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+from vspec.vssexporters.vss2graphql import Vss2Graphql
+
+
+def main(args):
+    vspec2vss_config = Vspec2VssConfig()
+    vss2graphql = Vss2Graphql(vspec2vss_config)
+    vspec2x = Vspec2X(vss2graphql, vspec2vss_config)
+    vspec2x.main(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

vss_tools-0.5.0.dev0.data/scripts/vspec2id.py

@@ -0,0 +1,28 @@
+#!python
+#
+# Copyright (c) 2023 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+#
+# Initialize static IDs.
+#
+
+import sys
+from vspec.vspec2x import Vspec2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+from vspec.vssexporters.vss2id import Vss2Id
+
+
+def main(arguments):
+    vspec2vss_config = Vspec2VssConfig()
+    vss2json = Vss2Id()
+    vspec2x = Vspec2X(vss2json, vspec2vss_config)
+    vspec2x.main(arguments)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

vss_tools-0.5.0.dev0.data/scripts/vspec2json.py

@@ -0,0 +1,29 @@
+#!python
+#
+# Copyright (c) 2023 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert vspec2json wrapper for vspec2x
+#
+
+import sys
+from vspec.vspec2x import Vspec2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+from vspec.vssexporters.vss2json import Vss2Json
+
+
+def main(args):
+    vspec2vss_config = Vspec2VssConfig()
+    vss2json = Vss2Json()
+    vspec2x = Vspec2X(vss2json, vspec2vss_config)
+    vspec2x.main(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

vss_tools-0.5.0.dev0.data/scripts/vspec2jsonschema.py

@@ -0,0 +1,29 @@
+#!python
+#
+# Copyright (c) 2023 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert vspec2jsonschema wrapper for vspec2x
+#
+
+import sys
+from vspec.vspec2x import Vspec2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+from vspec.vssexporters.vss2jsonschema import Vss2JsonSchema
+
+
+def main(args):
+    vspec2vss_config = Vspec2VssConfig()
+    vss2jsonschema = Vss2JsonSchema()
+    vspec2x = Vspec2X(vss2jsonschema, vspec2vss_config)
+    vspec2x.main(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

vss_tools-0.5.0.dev0.data/scripts/vspec2protobuf.py

@@ -0,0 +1,29 @@
+#!python
+#
+# Copyright (c) 2021 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert vspec2protobuf wrapper for vspec2x
+#
+
+import sys
+from vspec.vspec2x import Vspec2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+from vspec.vssexporters.vss2protobuf import Vss2Protobuf
+
+
+def main(args):
+    vspec2vss_config = Vspec2VssConfig()
+    vss2protobuf = Vss2Protobuf(vspec2vss_config)
+    vspec2x = Vspec2X(vss2protobuf, vspec2vss_config)
+    vspec2x.main(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

vss_tools-0.5.0.dev0.data/scripts/vspec2yaml.py

@@ -0,0 +1,29 @@
+#!python
+#
+# Copyright (c) 2021 Contributors to COVESA
+#
+# This program and the accompanying materials are made available under the
+# terms of the Mozilla Public License 2.0 which is available at
+# https://www.mozilla.org/en-US/MPL/2.0/
+#
+# SPDX-License-Identifier: MPL-2.0
+
+#
+# Convert vspec2yaml wrapper for vspec2x
+#
+
+import sys
+from vspec.vspec2x import Vspec2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+from vspec.vssexporters.vss2yaml import Vss2Yaml
+
+
+def main(args):
+    vspec2vss_config = Vspec2VssConfig()
+    vss2yaml = Vss2Yaml()
+    vspec2x = Vspec2X(vss2yaml, vspec2vss_config)
+    vspec2x.main(args)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])