fprime-gds 4.0.0a4__tar.gz → 4.0.0a6__tar.gz

{fprime_gds-4.0.0a4 → fprime_gds-4.0.0a6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a4
+Version: 4.0.0a6
 Summary: F Prime Flight Software Ground Data System layer
 Author-email: Michael Starch <Michael.D.Starch@jpl.nasa.gov>, Thomas Boyer-Chammard <Thomas.Boyer.Chammard@jpl.nasa.gov>
 License: 

{fprime_gds-4.0.0a4 → fprime_gds-4.0.0a6}/src/fprime_gds/common/pipeline/dictionaries.py

@@ -128,7 +128,13 @@ class Dictionaries:
             msg = f"[ERROR] Dictionary '{dictionary}' does not exist."
             raise Exception(msg)
         # Check for packet specification
-        if self._metadata["dictionary_type"] == "json":
+        if packet_spec is not None:
+            packet_loader = fprime_gds.common.loaders.pkt_xml_loader.PktXmlLoader()
+            self._packet_dict = packet_loader.get_id_dict(
+                packet_spec, self._channel_name_dict
+            )
+        # Otherwise use JSON dictionary to attempt automatic packet loading
+        elif self._metadata["dictionary_type"] == "json":
             packet_loader = fprime_gds.common.loaders.pkt_json_loader.PktJsonLoader(dictionary)
             if packet_set_name is None:
                 names = packet_loader.get_packet_set_names(None)
@@ -141,11 +147,6 @@ class Dictionaries:
             self._packet_dict = packet_loader.get_id_dict(
                 None, packet_set_name, self._channel_name_dict
             )
-        elif packet_spec is not None:
-            packet_loader = fprime_gds.common.loaders.pkt_xml_loader.PktXmlLoader(dictionary)
-            self._packet_dict = packet_loader.get_id_dict(
-                packet_spec, self._channel_name_dict
-            )
         else:
             self._packet_dict = None
 

{fprime_gds-4.0.0a4 → fprime_gds-4.0.0a6}/src/fprime_gds/common/testing_fw/api.py

@@ -11,6 +11,7 @@ import signal
 import time
 from pathlib import Path
 import shutil
+import json
 
 from fprime.common.models.serialize.time_type import TimeType
 
@@ -30,15 +31,17 @@ class IntegrationTestAPI(DataHandler):
 
     NOW = "NOW"
 
-    def __init__(self, pipeline, logpath=None, fsw_order=True):
+    def __init__(self, pipeline, deployment_config=None, logpath=None, fsw_order=True):
         """
         Initializes API: constructs and registers test histories.
         Args:
             pipeline: a pipeline object providing access to basic GDS functionality
+            deployment_config: path to deployment configuration file
             logpath: an optional output destination for the api test log
             fsw_order: a flag to determine whether the API histories will maintain FSW time order.
         """
         self.pipeline = pipeline
+        self.deployment_config = deployment_config
 
         # these are owned by the GDS and will not be modified by the test API.
         self.aggregate_command_history = pipeline.histories.commands
@@ -228,11 +231,29 @@ class IntegrationTestAPI(DataHandler):
 
     def get_deployment(self):
         """
-        Get the deployment of the target using the loaded FSW dictionary path
+        Get the deployment of the target using the loaded FSW dictionary.
+
         Returns:
-            The name of the deployment (str)
-        """
-        return Path(self.pipeline.dictionary_path).parent.parent.name
+            The name of the deployment (str) or None if not found
+        """
+        dictionary = str(self.pipeline.dictionary_path)
+
+        try:
+            with open(dictionary, 'r') as file:
+                data = json.load(file)
+            return data['metadata'].get("deploymentName")
+        except FileNotFoundError:
+            msg = f"Error: File not found at path: {dictionary}"
+            self.__log(msg, TestLogger.YELLOW)
+            return None
+        except json.JSONDecodeError as e:
+            msg = f"Error decoding JSON: {e}"
+            self.__log(msg, TestLogger.YELLOW)
+            return None
+        except Exception as e:
+            msg = f"An unexpected error occurred: {e} is an unknown key"
+            self.__log(msg, TestLogger.YELLOW)
+            return None
 
     def wait_for_dataflow(self, count=1, channels=None, start=None, timeout=120):
         """
@@ -257,6 +278,90 @@ class IntegrationTestAPI(DataHandler):
             assert False, msg
         self.remove_telemetry_subhistory(history)
 
+    def get_config_file_path(self):
+        """
+        Accessor for IntegrationTestAPI's deployment configuration file.
+
+        Returns:
+            path to user-specified deployment configuration file (str) or None if not defined
+        """
+        if self.deployment_config:
+            return self.deployment_config
+        else:
+            return None
+
+    def load_config_file(self):
+        """
+        Load user-specified deployment configuration JSON file.
+
+        Returns:
+            JSON object as a dictionary
+        """
+        config_file = self.get_config_file_path()
+
+        try:
+            with open(config_file, 'r') as file:
+                result = json.load(file)
+            return result
+        except FileNotFoundError:
+            msg = f"Error: File not found at path {config_file}"
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+        except json.JSONDecodeError as e:
+            msg = f"Error decoding JSON: {e}"
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+        except Exception as e:
+            msg = f"An unexpected error occurred: {e}"
+            self.__log(msg, TestLogger.RED)
+            assert False, msg
+
+    def get_mnemonic(self, comp=None, name=None):
+        """
+        Get deployment mnemonic of specified item from user-specified deployment
+        configuration file.
+
+        Args:
+            comp: qualified name of the component instance (str), i.e. "<component>.<instance>"
+            name: command, channel, or event name (str) [optional]
+        Returns:
+            deployment mnemonic of specified item (str) or native mnemonic (str) if not found
+        """
+        data = self.load_config_file()
+
+        if data:
+            try:
+                mnemonic = data[comp]
+                return f"{mnemonic}.{name}" if name else f"{mnemonic}"
+            except KeyError:
+                self.__log(f"Error: {comp} not found", TestLogger.YELLOW)
+                return f"{comp}.{name}" if name else f"{comp}"
+        else:
+            return f"{comp}.{name}" if name else f"{comp}"
+
+    def get_prm_db_path(self) -> str:
+        """
+        Get file path to parameter db from user-specified deployment configuration file.
+
+        Returns:
+            file path to parameter db (str) or None if not found
+        """
+        data = self.load_config_file()
+
+        if data:
+            try:
+                filepath = data["Svc.PrmDb.filename"]
+                if filepath.startswith('/'):
+                    return filepath
+                else:
+                    msg = f"Error: {filepath} did not start with a forward slash"
+                    self.__log(msg, TestLogger.RED)
+                    assert False, msg
+            except KeyError:
+                return None
+        else:
+            return None
+
     ######################################################################################
     #   History Functions
     ######################################################################################

{fprime_gds-4.0.0a4 → fprime_gds-4.0.0a6}/src/fprime_gds/common/testing_fw/pytest_integration.py

@@ -52,6 +52,12 @@ def pytest_addoption(parser):
         action="store_true",
         help="Enable JUnitXML report generation to a specified location"
     )
+    # Add an option to specify a json config file that maps components
+    parser.addoption(
+        "--deployment-config",
+        action="store",
+        help="Path to JSON configuration file for mapping deployment components"
+    )
 
 def pytest_configure(config):
     """ This is a hook to allow plugins and conftest files to perform initial configuration
@@ -85,6 +91,7 @@ def fprime_test_api_session(request):
     pipeline_parser = StandardPipelineParser()
     pipeline = None
     api = None
+    deployment_config = None
     try:
         # Parse the command line arguments into a client connection
         arg_ns = pipeline_parser.handle_arguments(request.config.known_args_namespace, client=True)
@@ -92,8 +99,12 @@ def fprime_test_api_session(request):
         # Build a new pipeline with the parsed and processed arguments
         pipeline = pipeline_parser.pipeline_factory(arg_ns, pipeline)
 
+        # Get deployment configuration from command line arguments
+        if request.config.option.deployment_config:
+            deployment_config = request.config.option.deployment_config
+
         # Build and set up the integration test api
-        api = IntegrationTestAPI(pipeline, arg_ns.logs)
+        api = IntegrationTestAPI(pipeline, deployment_config, arg_ns.logs)
         api.setup()
 
         # Return the API. Note: the second call here-in will begin after the yield and clean-up after the test

{fprime_gds-4.0.0a4 → fprime_gds-4.0.0a6}/src/fprime_gds/executables/apps.py

@@ -237,14 +237,18 @@ class GdsStandardApp(GdsApp):
         arguments needed for the given parsers.  When main is loaded, it will dispatch to the sub-classing plugin's
         start method. The subclassing plugin will already have had the arguments supplied via the PluginParser's
         construction of plugin objects.
+
+        Returns:
+            list of arguments to pass to subprocess
         """
         cls = self.__class__.__name__
         module = self.__class__.__module__
 
-        namespace = Namespace(**self.arguments)
-        args = CompositeParser(
+        composite_parser = CompositeParser(
             [self.get_cli_parser(), StandardPipelineParser]
-        ).reproduce_cli_args(namespace)
+        )
+        namespace, _, _ = ParserBase.parse_known_args([composite_parser])
+        args = composite_parser.reproduce_cli_args(namespace)
         return [sys.executable, "-c", f"import {module}\n{module}.{cls}.main()"] + args
 
     @classmethod
@@ -260,9 +264,10 @@ class GdsStandardApp(GdsApp):
             # triggered by the code above that turns it off in the not-setup case. 
             except AssertionError:
                 pass
+            plugin_name = getattr(cls, "get_name", lambda: cls.__name__)()
             parsed_arguments, _ = ParserBase.parse_args(
                 [cls.get_cli_parser(), StandardPipelineParser, PluginArgumentParser],
-                f"{cls.get_name()}: a standard app plugin",
+                f"{plugin_name}: a standard app plugin",
             )
             pipeline = StandardPipeline()
             # Turn off history and filing

{fprime_gds-4.0.0a4 → fprime_gds-4.0.0a6}/src/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,7 +192,7 @@ class QualifiedType(BaseModel):
         return v
 
 class StructMember(BaseModel):
-    type: Union[IntegerType, FloatType, BoolType, QualifiedType]
+    type: Union[IntegerType, FloatType, BoolType, StringType, QualifiedType]
     size: int = 1
 
 class StructType(BaseModel):
@@ -333,12 +205,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, FloatType, QualifiedType, StringType]
+    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, FloatType, QualifiedType, StringType]
 
     @field_validator('kind')
     def kind_qualifiedIdentifier(cls, v):
@@ -346,6 +230,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 +256,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 +278,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 +289,75 @@ 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]]:
+        # All types/constants that make up the DP header
+        header_dict = {
+            "FwPacketDescriptorType": None,
+            "FwDpIdType": None,
+            "FwDpPriorityType" : None,
+            "Seconds": None,
+            "USeconds": None,
+            "FwTimeBaseStoreType": None,
+            "FwTimeContextStoreType": None,
+            "Fw.DpCfg.ProcType": None,
+            "Fw.DpCfg.CONTAINER_USER_DATA_SIZE": None,
+            "Fw.DpState": None,
+            "FwSizeStoreType": None
+        }
+        for k in header_dict.keys():
+            # Seconds and USeconds are not in the dictionary, but are both always U32
+            if k == "Seconds" or k == "USeconds":
+                header_dict[k] = 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[k] = 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[k] = t
+                        break
+
+        return header_dict
+    
+    @computed_field
+    @property
+    def dataId(self) -> Type:
+        return self.header.get("FwDpIdType")
+    
+    @computed_field
+    @property
+    def dataSize(self) -> Type:
+        return self.header.get("FwSizeStoreType")
+
+    @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 = {
@@ -646,6 +593,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.
@@ -685,6 +633,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 = []
@@ -738,7 +688,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)
@@ -866,21 +822,28 @@ 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"]
+                    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)
 
                 # Read the total data size
-                dataSize = headerData['DataSize']
+                dataSize = headerData['FwSizeStoreType']
 
                 # Restart the count of bytes read
                 self.totalBytesRead = 0

{fprime_gds-4.0.0a4 → fprime_gds-4.0.0a6}/src/fprime_gds/executables/run_deployment.py

@@ -177,7 +177,7 @@ 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__)()
+    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",

{fprime_gds-4.0.0a4 → fprime_gds-4.0.0a6}/src/fprime_gds.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fprime-gds
-Version: 4.0.0a4
+Version: 4.0.0a6
 Summary: F Prime Flight Software Ground Data System layer
 Author-email: Michael Starch <Michael.D.Starch@jpl.nasa.gov>, Thomas Boyer-Chammard <Thomas.Boyer.Chammard@jpl.nasa.gov>
 License: