fprime-gds 3.6.1__py3-none-any.whl → 4.0.0__py3-none-any.whl

fprime_gds/executables/comm.py

@@ -29,6 +29,7 @@ import fprime_gds.common.logger
 import fprime_gds.executables.cli
 from fprime_gds.common.communication.updown import Downlinker, Uplinker
 from fprime_gds.common.zmq_transport import ZmqGround
+from fprime_gds.plugin.system import Plugins
 
 # Uses non-standard PIP package pyserial, so test the waters before getting a hard-import crash
 try:
@@ -46,6 +47,8 @@ def main():
 
     :return: return code
     """
+    # comm.py supports 2 and only 2 plugin categories
+    Plugins.system(["communication", "framing"])
     args, _ = fprime_gds.executables.cli.ParserBase.parse_args(
         [
             fprime_gds.executables.cli.LogDeployParser,
@@ -71,11 +74,11 @@ def main():
             args.tts_addr, args.tts_port
         )
 
-    adapter = args.communication_selection_instance
+    adapter = Plugins.system().get_selected_class("communication")()
 
     # Set the framing class used and pass it to the uplink and downlink component constructions giving each a separate
     # instantiation
-    framer_instance = args.framing_selection_instance
+    framer_instance = Plugins.system().get_selected_class("framing")()
     LOGGER.info(
         "Starting uplinker/downlinker connecting to FSW using %s with %s",
         args.communication_selection,

fprime_gds/executables/data_product_writer.py

@@ -72,7 +72,7 @@ import json
 import os
 import sys
 from typing import List, Dict, Union, ForwardRef
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, field_validator, computed_field, model_validator
 from typing import List, Union
 import argparse
 from binascii import crc32
@@ -88,128 +88,7 @@ class bcolors:
     UNDERLINE = '\033[4m'
 
 
-# This defines the data in the container header.  When this is ultimately defined in the json dictionary,
-# then this can be removed.
-header_data = {
-    "typeDefinitions" : [
-        {
-            "kind": "array",
-            "qualifiedName": "UserDataArray",
-            "size": 32,
-            "elementType": {
-                "name": "U8",
-                "kind": "integer",
-                "signed": False,
-                "size": 8
-            }
-        },
-
-        {
-            "kind": "struct",
-            "qualifiedName": "timeStruct",
-            "members": {
-                "seconds": {
-                    "type": {
-                        "name": "U32",
-                        "kind": "integer",
-                        "signed": False,
-                        "size": 32
-                    }
-                },
-                "useconds": {
-                    "type": {
-                        "name": "U32",
-                        "kind": "integer",
-                        "signed": False,
-                        "size": 32
-                    }
-                },
-                "timeBase": {
-                    "type": {
-                        "name": "U16",
-                        "kind": "integer",
-                        "signed": False,
-                        "size": 16
-                    }
-                },
-                "context": {
-                    "type": {
-                        "name": "U8",
-                        "kind": "integer",
-                        "signed": False,
-                        "size": 8
-                    }
-                }
-            }
-        }
-    ],
-
-    "enums" : [
-    ],
-
-    "header": {
-        "PacketDescriptor": {
-            "type": {
-                "name": "U32",
-                "kind": "integer",
-                "signed": False,
-                "size": 32
-            }
-        },
-        "Id": {
-            "type": {
-                "name": "U32",
-                "kind": "integer",
-                "signed": False,
-                "size": 32
-            }
-        },
-        "Priority": {
-            "type": {
-                "name": "U32",
-                "kind": "integer",
-                "signed": False,
-                "size": 32
-            }
-        },
-        "TimeTag": {
-            "type": {
-                "name": "timeStruct",
-                "kind": "qualifiedIdentifier"
-            }
-        },
-        "ProcTypes": {
-            "type": {
-                "name": "U8",
-                "kind": "integer",
-                "signed": False,
-                "size": 8
-            }
-        },
-        "UserData": {
-            "type": {
-                "name": "UserDataArray",
-                "kind": "qualifiedIdentifier"
-            }
-        },
-        "DpState": {
-            "type": {
-                "name": "U8",
-                "kind": "integer",
-                "signed": False,
-                "size": 8
-            }
-        },
-        "DataSize": {
-            "type": {
-                "name": "U16",
-                "kind": "integer",
-                "signed": False,
-                "size": 16
-            }       
-        }
-    },
-
+header_hash_data = {
     "headerHash": {
         "type": {
             "name": "U32",
@@ -218,25 +97,6 @@ header_data = {
             "size": 32
         }
     },
-
-    "dataId": {
-        "type": {
-            "name": "U32",
-            "kind": "integer",
-            "signed": False,
-            "size": 32
-        }
-    },
-
-    "dataSize": {
-        "type": {
-            "name": "U16",
-            "kind": "integer",
-            "signed": False,
-            "size": 16
-        }
-    },
-
     "dataHash": {
         "type": {
             "name": "U32",
@@ -305,9 +165,21 @@ class BoolType(BaseModel):
         if v != "bool":
             raise ValueError('Check the "kind" field')
         return v
+    
+class StringType(BaseModel):
+    name: str
+    kind: str
+    size: int
+
+    @field_validator('kind')
+    def kind_qualifiedIdentifier(cls, v):
+        if v != "string":
+            raise ValueError('Check the "kind" field')
+        return v
 
 Type = ForwardRef('Type')
 ArrayType = ForwardRef('ArrayType')
+AliasType = ForwardRef('AliasType')
 
 class QualifiedType(BaseModel):
     kind: str
@@ -320,8 +192,9 @@ class QualifiedType(BaseModel):
         return v
 
 class StructMember(BaseModel):
-    type: Union[IntegerType, FloatType, BoolType, QualifiedType]
+    type: Union[IntegerType, FloatType, BoolType, StringType, QualifiedType]
     size: int = 1
+    index: int
 
 class StructType(BaseModel):
     kind: str
@@ -333,12 +206,24 @@ class StructType(BaseModel):
         if v != "struct":
             raise ValueError('Check the "kind" field')
         return v
+    
+class AliasType(BaseModel):
+    kind: str
+    qualifiedName: str
+    type: Union[AliasType, StructType, ArrayType, IntegerType, BoolType, FloatType, StringType, QualifiedType]
+    underlyingType: Union[StructType, ArrayType, IntegerType, BoolType, FloatType, StringType, QualifiedType]
+
+    @field_validator('kind')
+    def kind_qualifiedIdentifier(cls, v):
+        if v != "alias":
+            raise ValueError('Check the "kind" field')
+        return v
 
 class ArrayType(BaseModel):
     kind: str
     qualifiedName: str
     size: int
-    elementType: Union[StructType, ArrayType, IntegerType, FloatType, QualifiedType]
+    elementType: Union[AliasType, StructType, ArrayType, IntegerType, BoolType, FloatType, StringType, QualifiedType]
 
     @field_validator('kind')
     def kind_qualifiedIdentifier(cls, v):
@@ -346,6 +231,12 @@ class ArrayType(BaseModel):
             raise ValueError('Check the "kind" field')
         return v
 
+class Constant(BaseModel):
+    qualifiedName: str
+    type: Union[IntegerType, FloatType, BoolType, StringType]
+    value: Union[int, float, bool, str]
+
+
 class EnumeratedConstant(BaseModel):
     name: str
     value: int
@@ -366,11 +257,11 @@ class EnumType(BaseModel):
 
 
 class Type(BaseModel):
-    type: Union[StructType, ArrayType, IntegerType, FloatType, BoolType, QualifiedType]
+    type: Union[AliasType, StructType, ArrayType, IntegerType, FloatType, BoolType, QualifiedType, StringType]
 
 class RecordStruct(BaseModel):
     name: str
-    type: Union[StructType, ArrayType, IntegerType, FloatType, BoolType, QualifiedType]
+    type: Union[AliasType, StructType, ArrayType, IntegerType, FloatType, BoolType, QualifiedType, StringType]
     array: bool
     id: int
     annotation: str
@@ -388,7 +279,8 @@ class ContainerStruct(BaseModel):
 
 class FprimeDict(BaseModel):
     metadata: Dict[str, Union[str, List[str]]]
-    typeDefinitions: List[Union[ArrayType, StructType, EnumType]]
+    typeDefinitions: List[Union[AliasType, ArrayType, StructType, EnumType]]
+    constants: List[Constant]
     records: List[RecordStruct]
     containers: List[ContainerStruct]
 
@@ -398,19 +290,82 @@ class FprimeDict(BaseModel):
 # -------------------------------------------------------------------------------------
 
 class DPHeader(BaseModel):
-    typeDefinitions: List[Union[ArrayType, StructType, EnumType]]
-    header: Dict[str, Type]
+    typeDefinitions: List[Union[AliasType, ArrayType, StructType, EnumType]]
+    constants: List[Constant]
     headerHash: Type
-    dataId: Type
-    dataSize: Type
     dataHash: Type
 
+    @computed_field
+    @property
+    def header(self) -> Dict[str, Union[Type, ArrayType, EnumType]]:
+        # Mapping from type/constant names to header field names
+        header_field_names = {
+            "FwPacketDescriptorType": "PacketDescriptor",
+            "FwDpIdType": "Id",
+            "FwDpPriorityType" : "Priority",
+            "Seconds": "Seconds",
+            "USeconds": "USeconds",
+            "FwTimeBaseStoreType": "TimeBase",
+            "FwTimeContextStoreType": "Context",
+            "Fw.DpCfg.ProcType": "ProcTypes",
+            "Fw.DpCfg.CONTAINER_USER_DATA_SIZE": "UserData",
+            "Fw.DpState": "DpState",
+            "FwSizeStoreType": "DataSize"
+        }
+        # All types/constants that make up the DP header
+        # Key: Values of above header_field_names
+        # Values: Initialized to None, populated below based on type names/constants in the JSON dictionary
+        header_dict = {v: None for v in header_field_names.values()}
+        for k, v in header_field_names.items():
+            # Seconds and USeconds are not in the dictionary, but are both always U32
+            if k == "Seconds" or k == "USeconds":
+                header_dict[v] = Type(type=IntegerType(name="U32", kind="integer", size=32, signed=False))
+            # According to Fw.Dp SDD, Header::UserData is an array of U8 of size Fw::DpCfg::CONTAINER_USER_DATA_SIZE.
+            elif k == "Fw.DpCfg.CONTAINER_USER_DATA_SIZE":
+                for t in self.constants:
+                    if t.qualifiedName == k:
+                        header_dict[v] = ArrayType(
+                            kind="array", 
+                            qualifiedName="UserData",
+                            size=t.value,
+                            elementType=IntegerType(name="U8", kind="integer", size=8, signed=False)
+                        )
+                        break
+            else:
+                for t in self.typeDefinitions:
+                    if t.qualifiedName == k:
+                        header_dict[v] = t
+                        break
+
+        return header_dict
+    
+    @computed_field
+    @property
+    def dataId(self) -> AliasType:
+        return self.header.get("Id")
+    
+    @computed_field
+    @property
+    def dataSize(self) -> AliasType:
+        return self.header.get("DataSize")
+
+    def get_size_store_bytes(self) -> int:
+        return self.header.get("DataSize").underlyingType.size // 8
+
+    @model_validator(mode='after')
+    def validate_header(self) -> 'DPHeader':
+        for k, v in self.header.items():
+            if not v:
+                raise ValueError(f'Dictionary is missing type definition or constant {k}.')
+        return self
+
 ArrayType.model_rebuild()
+AliasType.model_rebuild()
 StructType.model_rebuild()
 Type.model_rebuild()
 
-TypeKind = Union[StructType, ArrayType, IntegerType, FloatType, EnumType, BoolType, QualifiedType]
-TypeDef = Union[ArrayType, StructType]
+TypeKind = Union[AliasType, ArrayType, StructType, IntegerType, FloatType, EnumType, BoolType, QualifiedType, StringType]
+TypeDef = Union[AliasType, ArrayType, StructType]
 
 # Map the JSON types to struct format strings
 type_mapping = {
@@ -424,7 +379,8 @@ type_mapping = {
     'U64': 'Q', # Unsigned 64-bit integer
     'F32': 'f',  # 32-bit float
     'F64': 'd',  # 64-bit float
-    'bool': '?' # An 8 bit boolean
+    'bool': '?', # An 8 bit boolean
+    'string': 's'
     # Add more mappings as needed
 }
 
@@ -538,6 +494,7 @@ class DataProductWriter:
         self.binaryFileName = binaryFileName
         self.totalBytesRead = 0
         self.calculatedCRC = 0
+        self.headerJSON = None
 
 
     # ----------------------------------------------------------------------------------------------
@@ -573,8 +530,29 @@ class DataProductWriter:
         except KeyError:
             raise KeyError(f"Unrecognized JSON Dictionary Type: {intType}")
         data = struct.unpack(format_str, bytes_read)[0]
+        return data
+
+    def read_and_deserialize_string(self) -> str:
+        size_store_type_bytes = self.headerJSON.get_size_store_bytes()
+        bytes_read_store = self.binaryFile.read(size_store_type_bytes)
+        if len(bytes_read_store) != size_store_type_bytes:
+            raise IOError(f"Tried to read {size_store_type_bytes} bytes from the binary file, but failed.")
+
+        self.totalBytesRead += size_store_type_bytes
+        
+        format_str = f'{BIG_ENDIAN}H'
+        string_size_data = struct.unpack(format_str, bytes_read_store)[0]
+
+        bytes_read = self.binaryFile.read(string_size_data)
+        if len(bytes_read) != string_size_data:
+            raise IOError(f"Tried to read {string_size_data} bytes from the binary file, but failed.")
 
+        self.calculatedCRC = crc32(bytes_read_store + bytes_read, self.calculatedCRC) & 0xffffffff
+        self.totalBytesRead += string_size_data
 
+        format_str = f'{BIG_ENDIAN}{string_size_data}s'
+        data = struct.unpack(format_str, bytes_read)[0]
+        data = data.decode()
         return data
 
     # -----------------------------------------------------------------------------------------------------------------------
@@ -621,7 +599,7 @@ class DataProductWriter:
     #   AssertionError: If the field_config is not an IntegerType, FloatType, or BoolType.
     # -----------------------------------------------------------------------------------------------------------------------
 
-    def read_field(self, field_config: Union[IntegerType, FloatType, BoolType]) -> Union[int, float, bool]:
+    def read_field(self, field_config: Union[IntegerType, FloatType, BoolType, StringType]) -> Union[int, float, bool]:
 
         if type(field_config) is IntegerType:
             sizeBytes = field_config.size // 8
@@ -632,6 +610,9 @@ class DataProductWriter:
         elif type(field_config) is BoolType:
             sizeBytes = field_config.size // 8
 
+        elif type(field_config) is StringType:
+            return self.read_and_deserialize_string()
+
         else:
             assert False, "Unsupported typeKind encountered"
 
@@ -646,6 +627,7 @@ class DataProductWriter:
     #   The process varies depending on the field's type:
     #   - For basic types (IntegerType, FloatType, BoolType), it directly reads and assigns the value.
     #   - For EnumType, it reads the value, finds the corresponding enum identifier, and assigns it.
+    #   - For AliasType, it reads and assigns the value based on the alias' underlying type.
     #   - For ArrayType, it creates a list, iteratively fills it with elements read recursively, and assigns the list.
     #   - For StructType, it constructs a nested dictionary by recursively processing each struct member.
     #   - For QualifiedType, it resolves the actual type from typeList and recursively processes the field.
@@ -678,6 +660,8 @@ class DataProductWriter:
         elif isinstance(typeKind, BoolType):
             parent_dict[field_name] = self.read_field(typeKind)
 
+        elif isinstance(typeKind, StringType):
+            parent_dict[field_name] = self.read_field(typeKind)
 
         elif isinstance(typeKind, EnumType):
             value = self.read_field(typeKind.representationType)
@@ -685,6 +669,8 @@ class DataProductWriter:
             reverse_mapping = {enum.value: enum.name for enum in enum_mapping}
             parent_dict[field_name] = reverse_mapping[value]
 
+        elif isinstance(typeKind, AliasType):
+            self.get_struct_item(field_name, typeKind.underlyingType, typeList, parent_dict)
 
         elif isinstance(typeKind, ArrayType):
             array_list = []
@@ -696,7 +682,8 @@ class DataProductWriter:
 
         elif isinstance(typeKind, StructType):
             array_list = []
-            for key, member in typeKind.members.items():
+            sorted_members = dict(sorted(typeKind.members.items(), key=lambda member: member[1].index))
+            for key, member in sorted_members.items():
                 for i in range(member.size):
                     element_dict = {}
                     self.get_struct_item(key, member.type, typeList, element_dict)
@@ -738,7 +725,13 @@ class DataProductWriter:
         rootDict = {}
 
         for field_name, field_info in header_fields.items():
-            self.get_struct_item(field_name, field_info.type, headerJSON.typeDefinitions, rootDict)
+            # Header is composed of enums, arrays, and aliases
+            if isinstance(field_info, EnumType):
+                self.get_struct_item(field_name, field_info.representationType, headerJSON.typeDefinitions, rootDict)
+            elif isinstance(field_info, ArrayType):
+                self.get_struct_item(field_name, field_info, headerJSON.typeDefinitions, rootDict)
+            else:
+                self.get_struct_item(field_name, field_info.type, headerJSON.typeDefinitions, rootDict)
 
         computedHash = self.calculatedCRC
         rootDict['headerHash'] = self.read_field(headerJSON.headerHash.type)
@@ -775,7 +768,7 @@ class DataProductWriter:
     def get_record_data(self, headerJSON: DPHeader, dictJSON: FprimeDict) -> Dict[str, int]:
         rootDict = {}
         # Go through all the Records and find the one that matches recordId
-        rootDict['dataId'] = self.read_field(headerJSON.dataId.type)
+        rootDict['dataId'] = self.read_field(headerJSON.dataId.underlyingType)
         for record in dictJSON.records:
             if record.id == rootDict['dataId']:    
                 print(f'Processing Record ID {record.id}')
@@ -866,18 +859,25 @@ class DataProductWriter:
             print(f"Parsing {self.jsonDict}...")
             try:
                 with open(self.jsonDict, 'r') as fprimeDictFile:
-                    dictJSON = FprimeDict(**json.load(fprimeDictFile))
+                    dict_json = json.load(fprimeDictFile)
+                    dictJSON = FprimeDict(**dict_json)
+
+                    header_json = header_hash_data
+                    if "typeDefinitions" in dict_json:
+                        header_json["typeDefinitions"] = dict_json["typeDefinitions"]
+                    if "constants" in dict_json:
+                        header_json["constants"] = dict_json["constants"]
+                    self.headerJSON = DPHeader(**header_json)
+            
             except json.JSONDecodeError as e:
                 raise DictionaryError(self.jsonDict, e.lineno)
             
             self.check_record_data(dictJSON)
 
-            headerJSON = DPHeader(**header_data)
-
             with open(self.binaryFileName, 'rb') as self.binaryFile:
 
                 # Read the header data up until the Records
-                headerData = self.get_header_info(headerJSON)
+                headerData = self.get_header_info(self.headerJSON)
 
                 # Read the total data size
                 dataSize = headerData['DataSize']
@@ -888,13 +888,12 @@ class DataProductWriter:
                 recordList = [headerData]
 
                 while self.totalBytesRead < dataSize:
-
-                    recordData = self.get_record_data(headerJSON, dictJSON)
+                    recordData = self.get_record_data(self.headerJSON, dictJSON)
                     recordList.append(recordData)
 
                 computedCRC = self.calculatedCRC
                 # Read the data checksum
-                headerData['dataHash'] = self.read_field(headerJSON.dataHash.type)
+                headerData['dataHash'] = self.read_field(self.headerJSON.dataHash.type)
 
                 if computedCRC != headerData['dataHash']:
                     raise CRCError("Data", headerData['dataHash'], computedCRC)

fprime_gds/executables/fprime_cli.py

@@ -14,7 +14,7 @@ from copy import deepcopy
 from typing import Callable, List, Union
 
 import argcomplete
-import pkg_resources
+import importlib.metadata
 
 # NOTE: These modules are now only lazily loaded below as needed, due to slow
 # performance when importing them
@@ -230,7 +230,7 @@ class CommandSubparserInjector(CliSubparserInjectorBase):
         from fprime_gds.common.pipeline.dictionaries import Dictionaries
 
         dictionary = Dictionaries()
-        dictionary.load_dictionaries(dict_path, None)
+        dictionary.load_dictionaries(dict_path, None, None)
         command_names = dictionary.command_name.keys()
         return [name for name in command_names if name.startswith(prefix)]
 
@@ -322,7 +322,7 @@ def create_parser():
     parser = argparse.ArgumentParser(
         description="provides utilities for interacting with the F' Ground Data System (GDS)"
     )
-    fprime_gds_version = pkg_resources.get_distribution("fprime-gds").version
+    fprime_gds_version = importlib.metadata.version("fprime-gds")
     parser.add_argument("-V", "--version", action="version", version=fprime_gds_version)
 
     # Add subcommands to the parser

fprime_gds/executables/run_deployment.py

@@ -9,6 +9,7 @@ import webbrowser
 
 from fprime_gds.executables.cli import (
     BinaryDeployment,
+    ConfigDrivenParser,
     CommParser,
     GdsParser,
     ParserBase,
@@ -16,6 +17,7 @@ from fprime_gds.executables.cli import (
     PluginArgumentParser,
 )
 from fprime_gds.executables.utils import AppWrapperException, run_wrapped_application
+from fprime_gds.plugin.system import Plugins
 
 BASE_MODULE_ARGUMENTS = [sys.executable, "-u", "-m"]
 
@@ -36,7 +38,7 @@ def parse_args():
         PluginArgumentParser,
     ]
     # Parse the arguments, and refine through all handlers
-    args, parser = ParserBase.parse_args(arg_handlers, "Run F prime deployment and GDS")
+    args, parser = ConfigDrivenParser.parse_args(arg_handlers, "Run F prime deployment and GDS")
     return args
 
 
@@ -174,8 +176,8 @@ def launch_comm(parsed_args):
 
 
 def launch_plugin(plugin_class_instance):
-    """ Launch a plugin instance """
-    plugin_name = getattr(plugin_class_instance, "get_name", lambda: cls.__name__)()
+    """Launch a plugin instance"""
+    plugin_name = getattr(plugin_class_instance, "get_name", lambda: plugin_class_instance.__class__.__name__)()
     return launch_process(
         plugin_class_instance.get_process_invocation(),
         name=f"{ plugin_name } Plugin App",
@@ -215,8 +217,14 @@ def main():
     # Launch launchers and wait for the last app to finish
     try:
         procs = [launcher(parsed_args) for launcher in launchers]
-        _ = [launch_plugin(cls) for cls in  parsed_args.gds_app_enabled_instances]
-        _ = [instance.run() for instance in parsed_args.gds_function_enabled_instances]
+        _ = [
+            launch_plugin(cls())
+            for cls in Plugins.system().get_feature_classes("gds_app")
+        ]
+        _ = [
+            instance().run()
+            for instance in Plugins.system().get_feature_classes("gds_function")
+        ]
 
         print("[INFO] F prime is now running. CTRL-C to shutdown all components.")
         procs[-1].wait()

fprime_gds/flask/app.py

@@ -84,6 +84,7 @@ def construct_app():
             pipeline.dictionaries.command_name,
             pipeline.dictionaries.project_version,
             pipeline.dictionaries.framework_version,
+            pipeline.dictionaries.metadata,
         ],
     )
     api.add_resource(
@@ -103,6 +104,7 @@ def construct_app():
             pipeline.dictionaries.event_id,
             pipeline.dictionaries.project_version,
             pipeline.dictionaries.framework_version,
+            pipeline.dictionaries.metadata,
         ],
     )
     api.add_resource(
@@ -117,6 +119,7 @@ def construct_app():
             pipeline.dictionaries.channel_id,
             pipeline.dictionaries.project_version,
             pipeline.dictionaries.framework_version,
+            pipeline.dictionaries.metadata,
         ],
     )
     api.add_resource(

fprime_gds/flask/resource.py

@@ -17,17 +17,19 @@ class DictionaryResource(Resource):
     should be flask compatible. Errors with the dictionary are a 500 server error and may not be recovered.
     """
 
-    def __init__(self, dictionary, project_version, framework_version):
+    def __init__(self, dictionary, project_version, framework_version, metadata):
         """Constructor used to setup for dictionary
 
         Args:
             dictionary: dictionary to serve when GET is called
             project_version: project version for the dictionary
             framework_version: project version for the dictionary
+            metadata (dict): additional metadata to serve with the dictionary
         """
         self.dictionary = dictionary
         self.project_version = project_version
         self.framework_version = framework_version
+        self.metadata = metadata
 
     def get(self):
         """HTTP GET method handler for dictionary resource
@@ -38,7 +40,8 @@ class DictionaryResource(Resource):
         return {
             "dictionary": self.dictionary,
             "project_version": self.project_version,
-            "framework_version": self.framework_version
+            "framework_version": self.framework_version,
+            "metadata": self.metadata
         }