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

vspec/vssexporters/vss2graphql.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+
+# 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
+
+import argparse
+from vspec.model.vsstree import VSSNode
+from vspec.utils.stringstyle import camel_back
+from vspec.model.constants import VSSDataType
+from vspec import VSpecError
+from typing import Dict
+from typing import Optional
+from vspec.vss2x import Vss2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+
+from graphql import (
+    GraphQLSchema,
+    GraphQLObjectType,
+    GraphQLField,
+    GraphQLArgument,
+    GraphQLNonNull,
+    GraphQLString,
+    GraphQLList,
+    print_schema,
+    GraphQLInt,
+    GraphQLFloat,
+    GraphQLBoolean,
+)
+
+GRAPHQL_TYPE_MAPPING = {
+    VSSDataType.INT8: GraphQLInt,
+    VSSDataType.INT8_ARRAY: GraphQLList(GraphQLInt),
+    VSSDataType.UINT8: GraphQLInt,
+    VSSDataType.UINT8_ARRAY: GraphQLList(GraphQLInt),
+    VSSDataType.INT16: GraphQLInt,
+    VSSDataType.INT16_ARRAY: GraphQLList(GraphQLInt),
+    VSSDataType.UINT16: GraphQLInt,
+    VSSDataType.UINT16_ARRAY: GraphQLList(GraphQLInt),
+    VSSDataType.INT32: GraphQLInt,
+    VSSDataType.INT32_ARRAY: GraphQLList(GraphQLInt),
+    VSSDataType.UINT32: GraphQLFloat,
+    VSSDataType.UINT32_ARRAY: GraphQLList(GraphQLFloat),
+    VSSDataType.INT64: GraphQLFloat,
+    VSSDataType.INT64_ARRAY: GraphQLList(GraphQLFloat),
+    VSSDataType.UINT64: GraphQLFloat,
+    VSSDataType.UINT64_ARRAY: GraphQLList(GraphQLFloat),
+    VSSDataType.FLOAT: GraphQLFloat,
+    VSSDataType.FLOAT_ARRAY: GraphQLList(GraphQLFloat),
+    VSSDataType.DOUBLE: GraphQLFloat,
+    VSSDataType.DOUBLE_ARRAY: GraphQLList(GraphQLFloat),
+    VSSDataType.BOOLEAN: GraphQLBoolean,
+    VSSDataType.BOOLEAN_ARRAY: GraphQLList(GraphQLBoolean),
+    VSSDataType.STRING: GraphQLString,
+    VSSDataType.STRING_ARRAY: GraphQLList(GraphQLString),
+}
+
+
+def get_schema_from_tree(root_node: VSSNode, additional_leaf_fields: list) -> str:
+    """Takes a VSSNode and additional fields for the leafs. Returns a graphql schema as string."""
+    args = dict(
+        id=GraphQLArgument(
+            GraphQLNonNull(GraphQLString),
+            description="VIN of the vehicle that you want to request data for.",
+        ),
+        after=GraphQLArgument(
+            GraphQLString,
+            description=(
+                "Filter data to only provide information that was sent "
+                "from the vehicle after that timestamp."
+            ),
+        ),
+    )
+
+    root_query = GraphQLObjectType(
+        "Query",
+        lambda: {"vehicle": GraphQLField(to_gql_type(root_node, additional_leaf_fields), args)},
+    )
+    return print_schema(GraphQLSchema(root_query))
+
+
+def to_gql_type(node: VSSNode, additional_leaf_fields: list) -> GraphQLObjectType:
+    return GraphQLObjectType(
+        name=node.qualified_name("_"),
+        fields=leaf_fields(node, additional_leaf_fields) if hasattr(
+            node, "datatype") else branch_fields(node, additional_leaf_fields),
+        description=node.description,
+    )
+
+
+def leaf_fields(node: VSSNode, additional_leaf_fields: list) -> Dict[str, GraphQLField]:
+    field_dict = {}
+    if node.datatype is not None:
+        field_dict["value"] = field(node, "Value: ", GRAPHQL_TYPE_MAPPING[node.datatype])
+    field_dict["timestamp"] = field(node, "Timestamp: ")
+    if additional_leaf_fields:
+        for additional_field in additional_leaf_fields:
+            if len(additional_field) == 2:
+                field_dict[additional_field[0]] = field(node, f" {str(additional_field[1])}: ")
+            else:
+                raise VSpecError("", "", "Incorrect format of graphql field specification")
+    if node.has_unit():
+        field_dict["unit"] = field(node, "Unit of ")
+    return field_dict
+
+
+def branch_fields(node: VSSNode, additional_leaf_fields: list) -> Dict[str, GraphQLField]:
+    # we only consider nodes that either have children or are leave with a datatype
+    valid = (c for c in node.children if len(c.children) or hasattr(c, "datatype"))
+    return {camel_back(c.name): field(c, type=to_gql_type(c, additional_leaf_fields)) for c in valid}
+
+
+def field(node: VSSNode, description_prefix="", type=GraphQLString) -> GraphQLField:
+    return GraphQLField(
+        type,
+        deprecation_reason=node.deprecation or None,
+        description=f"{description_prefix}{node.description}",
+    )
+
+
+class Vss2Graphql(Vss2X):
+
+    def __init__(self, vspec2vss_config: Vspec2VssConfig):
+        vspec2vss_config.no_expand_option_supported = False
+        vspec2vss_config.type_tree_supported = False
+        vspec2vss_config.uuid_supported = False
+
+    def add_arguments(self, parser: argparse.ArgumentParser):
+        parser.add_argument('--gqlfield', action='append', nargs=2,
+                            help=" Add additional fields to the nodes in the graphql schema. "
+                                 "use: <field_name> <description>")
+
+    def generate(self, config: argparse.Namespace, signal_root: VSSNode, vspec2vss_config: Vspec2VssConfig,
+                 data_type_root: Optional[VSSNode] = None) -> None:
+        print("Generating graphql output...")
+        outfile = open(config.output_file, 'w')
+        outfile.write(get_schema_from_tree(signal_root, config.gqlfield))
+        outfile.write("\n")
+        outfile.close()

vspec/vssexporters/vss2id.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+#
+# 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
+#
+# Generate IDs of 4bytes size, 3 bytes incremental value + 1 byte for layer id.
+
+import argparse
+import logging
+import os
+import sys
+from typing import Dict, Tuple, Optional
+
+import yaml
+
+from vspec import load_tree
+from vspec.model.constants import VSSTreeType
+from vspec.model.vsstree import VSSNode
+from vspec.utils import vss2id_val
+from vspec.utils.idgen_utils import (fnv1_32_hash, get_all_keys_values,
+                                     get_node_identifier_bytes)
+from vspec.vss2x import Vss2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+
+
+def generate_split_id(
+    node: VSSNode, id_counter: int, strict_mode: bool
+) -> Tuple[str, int]:
+
+    """Generates static UIDs using 4-byte FNV-1 hash.
+
+    @param node: VSSNode that we want to generate a static UID for
+    @param id_counter: consecutive numbers counter for amount of nodes
+    @param strict_mode: strict mode means case sensitivity for static UID generation
+    @return: tuple of hashed string and id counter
+    """
+
+    if hasattr(node, "fka") and node.fka:
+        name = node.fka[0] if isinstance(node.fka, list) else node.fka
+    else:
+        name = node.qualified_name()
+    identifier = get_node_identifier_bytes(
+        name,
+        node.data_type_str,
+        node.type.value,
+        node.get_unit(),
+        node.allowed,
+        node.min,
+        node.max,
+        strict_mode,
+    )
+    hashed_str = format(fnv1_32_hash(identifier), "08X")
+
+    return hashed_str, id_counter + 1
+
+
+def export_node(yaml_dict, node, id_counter, strict_mode: bool) -> Tuple[int, int]:
+    """Recursive function to export the full tree to a dict
+
+    @param yaml_dict: the to be exported dict
+    @param node: parent node of the tree
+    @param id_counter: counter for amount of ids
+    @param strict_mode: strict mode means case sensitivity for static UID generation
+    @return: id_counter, id_counter
+    """
+    node_id, id_counter = generate_split_id(node, id_counter, strict_mode)
+
+    # check for hash duplicates
+    for key, value in get_all_keys_values(yaml_dict):
+        if not isinstance(value, dict) and key == "staticUID":
+            if node_id == value[2:]:
+                logging.fatal(
+                    f"There is a small chance that the result of FNV-1 "
+                    f"hashes are the same in this case the hash of node "
+                    f"'{node.qualified_name()}' is the same as another hash."
+                    f"Can you please update it."
+                )
+                # We could add handling of duplicates here
+                sys.exit(-1)
+
+    node_path = node.qualified_name()
+
+    yaml_dict[node_path] = {"staticUID": f"0x{node_id}"}
+    yaml_dict[node_path]["description"] = node.description
+    yaml_dict[node_path]["type"] = str(node.type.value)
+    if node.unit:
+        yaml_dict[node_path]["unit"] = str(node.unit.value)
+    if node.is_signal() or node.is_property():
+        yaml_dict[node_path]["datatype"] = node.data_type_str
+    if node.allowed:
+        yaml_dict[node_path]["allowed"] = node.allowed
+    if node.min:
+        yaml_dict[node_path]["min"] = node.min
+    if node.max:
+        yaml_dict[node_path]["max"] = node.max
+
+    if node.fka:
+        yaml_dict[node_path]["fka"] = node.fka
+    elif "fka" in node.extended_attributes.keys():
+        yaml_dict[node_path]["fka"] = node.extended_attributes["fka"]
+
+    if node.deprecation:
+        yaml_dict[node_path]["deprecation"] = node.deprecation
+
+    for child in node.children:
+        id_counter, id_counter = export_node(yaml_dict, child, id_counter, strict_mode)
+
+    return id_counter, id_counter
+
+
+class Vss2Id(Vss2X):
+
+    def add_arguments(self, parser: argparse.ArgumentParser) -> None:
+        """Adds command line arguments to a pre-existing argument parser
+
+        @param parser: the pre-existing argument parser
+        """
+        parser.add_argument(
+            "--validate-static-uid", type=str, default="", help="Path to validation file."
+        )
+        parser.add_argument(
+            "--only-validate-no-export",
+            action="store_true",
+            default=False,
+            help="For pytests and pipelines you can skip the export of the vspec file.",
+        )
+        parser.add_argument(
+            "--strict-mode",
+            action="store_true",
+            help="Strict mode means that the generation of static UIDs is case-sensitive.",
+        )
+
+    def generate(self, config: argparse.Namespace, signal_root: VSSNode, vspec2vss_config: Vspec2VssConfig,
+                 data_type_root: Optional[VSSNode] = None) -> None:
+
+        """Main export function used to generate the output id vspec.
+
+        @param config: Command line arguments it was run with
+        @param signal_root: root of the signal tree
+        @param print_uuid: Not used here but needed by main script
+        """
+        logging.info("Generating YAML output...")
+
+        id_counter: int = 0
+        signals_yaml_dict: Dict[str, str] = {}  # Use str for ID values
+        id_counter, _ = export_node(
+            signals_yaml_dict, signal_root, id_counter, config.strict_mode
+        )
+
+        if config.validate_static_uid:
+            logging.info(
+                f"Now validating nodes, static UIDs, types, units and description with "
+                f"file '{config.validate_static_uid}'"
+            )
+            if os.path.isabs(config.validate_static_uid):
+                other_path = config.validate_static_uid
+            else:
+                other_path = os.path.join(os.getcwd(), config.validate_static_uid)
+
+            validation_tree = load_tree(
+                other_path, ["."], tree_type=VSSTreeType.SIGNAL_TREE
+            )
+            vss2id_val.validate_static_uids(signals_yaml_dict, validation_tree, config)
+
+        if not config.only_validate_no_export:
+            with open(config.output_file, "w") as f:
+                yaml.dump(signals_yaml_dict, f)

vspec/vssexporters/vss2json.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+
+# 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 vspec tree to JSON
+
+from vspec.model.vsstree import VSSNode
+import argparse
+import json
+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(json_dict, node, config, print_uuid):
+
+    json_dict[node.name] = {}
+
+    if node.is_signal() or node.is_property():
+        json_dict[node.name]["datatype"] = node.data_type_str
+
+    json_dict[node.name]["type"] = str(node.type.value)
+
+    # many optional attributes are initilized to "" in vsstree.py
+    if node.min != "":
+        json_dict[node.name]["min"] = node.min
+    if node.max != "":
+        json_dict[node.name]["max"] = node.max
+    if node.allowed != "":
+        json_dict[node.name]["allowed"] = node.allowed
+    if node.default != "":
+        json_dict[node.name]["default"] = node.default
+    if node.deprecation != "":
+        json_dict[node.name]["deprecation"] = node.deprecation
+
+    # in case of unit or aggregate, the attribute will be missing
+    try:
+        json_dict[node.name]["unit"] = str(node.unit.value)
+    except AttributeError:
+        pass
+    try:
+        json_dict[node.name]["aggregate"] = node.aggregate
+    except AttributeError:
+        pass
+
+    json_dict[node.name]["description"] = node.description
+    if node.comment != "":
+        json_dict[node.name]["comment"] = node.comment
+
+    if print_uuid:
+        json_dict[node.name]["uuid"] = node.uuid
+
+    for k, v in node.extended_attributes.items():
+        if not config.json_all_extended_attributes and k not in VSSNode.whitelisted_extended_attributes:
+            continue
+        json_dict[node.name][k] = v
+
+    # Include instance information if we run tool in "no-expand" mode
+    if config.no_expand and node.instances is not None:
+        json_dict[node.name]["instances"] = node.instances
+
+    # Might be better to not generate child dict, if there are no children
+    # if node.type == VSSType.BRANCH and len(node.children) != 0:
+    #    json_dict[node.name]["children"]={}
+
+    # But old JSON code always generates children, so lets do so to
+    if node.is_branch() or node.is_struct():
+        json_dict[node.name]["children"] = {}
+
+    for child in node.children:
+        export_node(json_dict[node.name]["children"],
+                    child, config, print_uuid)
+
+
+class Vss2Json(Vss2X):
+
+    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 JSON output...")
+        indent = None
+        if config.json_pretty:
+            logging.info("Serializing pretty JSON...")
+            indent = 2
+        else:
+            logging.info("Serializing compact JSON...")
+
+        signals_json_dict: Dict[str, Any] = {}
+        export_node(signals_json_dict, signal_root, config, vspec2vss_config.generate_uuid)
+
+        if data_type_root is not None:
+            data_types_json_dict: Dict[str, Any] = {}
+            export_node(data_types_json_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_json_dict["ComplexDataTypes"] = data_types_json_dict
+            else:
+                with open(config.types_output_file, 'w') as f:
+                    json.dump(data_types_json_dict, f, indent=indent, sort_keys=True)
+
+        with open(config.output_file, 'w') as f:
+            json.dump(signals_json_dict, f, indent=indent, sort_keys=True)

vspec/vssexporters/vss2jsonschema.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+#
+# 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 vspec tree compatible JSON schema
+
+import argparse
+import json
+import logging
+from typing import Dict, Any
+from typing import Optional
+from vspec.model.vsstree import VSSNode
+from vspec.vss2x import Vss2X
+from vspec.vspec2vss_config import Vspec2VssConfig
+
+type_map = {
+    "int8": "integer",
+    "uint8": "integer",
+    "int16": "integer",
+    "uint16": "integer",
+    "int32": "integer",
+    "uint32": "integer",
+    "int64": "integer",
+    "uint64": "integer",
+    "boolean": "boolean",
+    "float": "number",
+    "double": "number",
+    "string": "string",
+    "int8[]": "array",
+    "uint8[]": "array",
+    "int16[]": "array",
+    "uint16[]": "array",
+    "int32[]": "array",
+    "uint32[]": "array",
+    "int64[]": "array",
+    "uint64[]": "array",
+    "boolean[]": "array",
+    "float[]": "array",
+    "double[]": "array",
+    "string[]": "array"
+}
+
+
+def export_node(json_dict, node, config, print_uuid):
+    """Preparing nodes for JSON schema output."""
+    # keyword with X- sign are left for extensions and they are not part of official JSON schema
+    json_dict[node.name] = {
+        "description": node.description,
+    }
+
+    if node.is_signal() or node.is_property():
+        json_dict[node.name]["type"] = type_map[node.data_type_str]
+
+    # many optional attributes are initialized to "" in vsstree.py
+    if node.min != "":
+        json_dict[node.name]["minimum"] = node.min
+    if node.max != "":
+        json_dict[node.name]["maximum"] = node.max
+    if node.allowed != "":
+        json_dict[node.name]["enum"] = node.allowed
+    if node.default != "":
+        json_dict[node.name]["default"] = node.default
+    if node.is_struct():
+        # change type to object
+        json_dict[node.type]["type"] = "object"
+
+    if config.jsonschema_all_extended_attributes:
+        if node.type != "":
+            json_dict[node.name]["x-VSStype"] = str(node.type.value)
+        if node.data_type_str != "":
+            json_dict[node.name]["x-datatype"] = node.data_type_str
+        if node.deprecation != "":
+            json_dict[node.name]["x-deprecation"] = node.deprecation
+
+        # in case of unit or aggregate, the attribute will be missing
+        try:
+            json_dict[node.name]["x-unit"] = str(node.unit.value)
+        except AttributeError:
+            pass
+        try:
+            json_dict[node.name]["x-aggregate"] = node.aggregate
+            if node.aggregate:
+                # change type to object
+                json_dict[node.type]["type"] = "object"
+        except AttributeError:
+            pass
+
+        if node.comment != "":
+            json_dict[node.name]["x-comment"] = node.comment
+
+        if print_uuid:
+            json_dict[node.name]["x-uuid"] = node.uuid
+
+    for k, v in node.extended_attributes.items():
+        json_dict[node.name][k] = v
+
+    # Generate child nodes
+    if node.is_branch() or node.is_struct():
+        if config.jsonschema_disallow_additional_properties:
+            json_dict[node.name]["additionalProperties"] = False
+        json_dict[node.name]["properties"] = {}
+        if config.jsonschema_require_all_properties:
+            json_dict[node.name]["required"] = [child.name for child in node.children]
+        for child in node.children:
+            export_node(json_dict[node.name]["properties"], child, config, print_uuid)
+
+
+class Vss2JsonSchema(Vss2X):
+
+    def add_arguments(self, parser: argparse.ArgumentParser):
+        """Check for input arguments."""
+        parser.add_argument('--jsonschema-all-extended-attributes', action='store_true',
+                            help="Generate all extended attributes found in the model."
+                            "Should not be used with strict mode JSON Schema validators.")
+        parser.add_argument("--jsonschema-disallow-additional-properties", action='store_true',
+                            help="Do not allow properties not defined in VSS tree")
+        parser.add_argument("--jsonschema-require-all-properties", action='store_true',
+                            help="Require all elements defined in VSS tree for a valid object")
+        parser.add_argument('--jsonschema-pretty', action='store_true',
+                            help=" Pretty print JSON Schema output.")
+
+    def generate(self, config: argparse.Namespace, signal_root: VSSNode, vspec2vss_config: Vspec2VssConfig,
+                 data_type_root: Optional[VSSNode] = None) -> None:
+        """Export function for generating JSON schema file."""
+        logging.info("Generating JSON schema...")
+        indent = None
+        if config.jsonschema_pretty:
+            logging.info("Serializing pretty JSON schema...")
+            indent = 2
+
+        signals_json_schema: Dict[str, Any] = {}
+        export_node(signals_json_schema, signal_root, config, vspec2vss_config.generate_uuid)
+
+        # Add data types to the schema
+        if data_type_root is not None:
+            data_types_json_schema: Dict[str, Any] = {}
+            export_node(data_types_json_schema, data_type_root, config, vspec2vss_config.generate_uuid)
+            if config.jsonschema_all_extended_attributes:
+                signals_json_schema["x-ComplexDataTypes"] = data_types_json_schema
+
+        # VSS models only have one root, so there should only be one
+        # key in the dict
+        assert (len(signals_json_schema.keys()) == 1)
+        top_node_name = list(signals_json_schema.keys())[0]
+        signals_json_schema = signals_json_schema.pop(top_node_name)
+
+        json_schema = {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "title": top_node_name,
+            "type": "object",
+            **signals_json_schema}
+        with open(config.output_file, 'w', encoding="utf-8") as output_file:
+            json.dump(json_schema, output_file, indent=indent, sort_keys=False)