fprime-gds 3.6.0__tar.gz → 3.6.2a1__tar.gz

{fprime_gds-3.6.0 → fprime_gds-3.6.2a1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fprime-gds
-Version: 3.6.0
+Version: 3.6.2a1
 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-3.6.0 → fprime_gds-3.6.2a1}/src/fprime_gds/common/loaders/json_loader.py

@@ -71,6 +71,18 @@ class JsonLoader(dict_loader.DictLoader):
             self.json_dict["metadata"].get("projectVersion", "unknown"),
         )
 
+    def get_metadata(self):
+        """Get the metadata field of the JSON dictionary
+
+        Raises:
+            GdsDictionaryParsingException: if the dictionary has no metadata field
+        """
+        if "metadata" not in self.json_dict:
+            raise GdsDictionaryParsingException(
+                f"Dictionary has no metadata field: {self.json_file}"
+            )
+        return self.json_dict["metadata"]
+
     def parse_type(self, type_dict: dict) -> BaseType:
         type_name: str = type_dict.get("name", None)
 
@@ -102,6 +114,9 @@ class JsonLoader(dict_loader.DictLoader):
                 f"Dictionary type name has no corresponding type definition: {type_name}"
             )
 
+        if qualified_type.get("kind") == "alias":
+            return self.parse_type(qualified_type.get("underlyingType"))
+        
         if qualified_type.get("kind") == "array":
             return self.construct_array_type(type_name, qualified_type)
 

{fprime_gds-3.6.0 → fprime_gds-3.6.2a1}/src/fprime_gds/common/pipeline/dictionaries.py

@@ -7,20 +7,16 @@ class called "Dictionaries".
 @author mstarch
 """
 
-import os
 from pathlib import Path
 
-import fprime_gds.common.loaders.ch_py_loader
-import fprime_gds.common.loaders.ch_xml_loader
-
-# Py Loaders
-import fprime_gds.common.loaders.cmd_py_loader
 
 # XML Loaders
+import fprime_gds.common.loaders.ch_xml_loader
 import fprime_gds.common.loaders.cmd_xml_loader
-import fprime_gds.common.loaders.event_py_loader
 import fprime_gds.common.loaders.event_xml_loader
 import fprime_gds.common.loaders.pkt_xml_loader
+
+# JSON Loaders
 import fprime_gds.common.loaders.ch_json_loader
 import fprime_gds.common.loaders.cmd_json_loader
 import fprime_gds.common.loaders.event_json_loader
@@ -50,6 +46,7 @@ class Dictionaries:
         self._channel_name_dict = None
         self._packet_dict = None
         self._versions = None
+        self._metadata = None
 
     def load_dictionaries(self, dictionary, packet_spec):
         """
@@ -59,57 +56,39 @@ class Dictionaries:
         :param dictionary: dictionary path used for loading dictionaries
         :param packet_spec: specification for packets, or None, for packetized telemetry
         """
-        # Loading the dictionaries from a directory. A directory indicates heritage python dicts.
-        if os.path.isdir(dictionary):
-            # Events
-            event_loader = fprime_gds.common.loaders.event_py_loader.EventPyLoader()
-            self._event_id_dict = event_loader.get_id_dict(
-                os.path.join(dictionary, "events")
-            )
-            self._event_name_dict = event_loader.get_name_dict(
-                os.path.join(dictionary, "events")
-            )
-            # Commands
-            command_loader = fprime_gds.common.loaders.cmd_py_loader.CmdPyLoader()
-            self._command_id_dict = command_loader.get_id_dict(
-                os.path.join(dictionary, "commands")
-            )
-            self._command_name_dict = command_loader.get_name_dict(
-                os.path.join(dictionary, "commands")
-            )
-            # Channels
-            channel_loader = fprime_gds.common.loaders.ch_py_loader.ChPyLoader()
-            self._channel_id_dict = channel_loader.get_id_dict(
-                os.path.join(dictionary, "channels")
-            )
-            self._channel_name_dict = channel_loader.get_name_dict(
-                os.path.join(dictionary, "channels")
-            )
-        elif Path(dictionary).is_file() and ".json" in Path(dictionary).suffixes:
+        if Path(dictionary).is_file() and ".json" in Path(dictionary).suffixes:
             # Events
             json_event_loader = (
                 fprime_gds.common.loaders.event_json_loader.EventJsonLoader(dictionary)
             )
             self._event_name_dict = json_event_loader.get_name_dict(None)
             self._event_id_dict = json_event_loader.get_id_dict(None)
-            self._versions = json_event_loader.get_versions()
             # Commands
             json_command_loader = (
                 fprime_gds.common.loaders.cmd_json_loader.CmdJsonLoader(dictionary)
             )
             self._command_name_dict = json_command_loader.get_name_dict(None)
             self._command_id_dict = json_command_loader.get_id_dict(None)
-            assert (
-                self._versions == json_command_loader.get_versions()
-            ), "Version mismatch while loading"
             # Channels
             json_channel_loader = fprime_gds.common.loaders.ch_json_loader.ChJsonLoader(
                 dictionary
             )
             self._channel_name_dict = json_channel_loader.get_name_dict(None)
             self._channel_id_dict = json_channel_loader.get_id_dict(None)
+            # Metadata
+            self._versions = json_event_loader.get_versions()
+            self._metadata = json_event_loader.get_metadata().copy()
+            self._metadata["dictionary_type"] = "json"
+            # Each loaders should agree on metadata and versions
+            assert (
+                json_command_loader.get_metadata()
+                == json_channel_loader.get_metadata()
+                == json_event_loader.get_metadata()
+            ), "Metadata mismatch while loading"
             assert (
-                self._versions == json_channel_loader.get_versions()
+                json_command_loader.get_versions()
+                == json_channel_loader.get_versions()
+                == json_event_loader.get_versions()
             ), "Version mismatch while loading"
         # XML dictionaries
         elif Path(dictionary).is_file():
@@ -132,6 +111,12 @@ class Dictionaries:
             assert (
                 self._versions == channel_loader.get_versions()
             ), "Version mismatch while loading"
+            # versions are camelCase to match the metadata field of the JSON dictionaries
+            self._metadata = {
+                "frameworkVersion": self._versions[0],
+                "projectVersion": self._versions[1],
+                "dictionary_type": "xml",
+            }
         else:
             msg = f"[ERROR] Dictionary '{dictionary}' does not exist."
             raise Exception(msg)
@@ -184,6 +169,14 @@ class Dictionaries:
         """Framework version in dictionary"""
         return self._versions[0]
 
+    @property
+    def metadata(self):
+        """Dictionary metadata.
+
+        Note: framework_version and project_version are also available as separate properties
+        for legacy reasons. New code should use the metadata property."""
+        return self._metadata
+
     @property
     def packet(self):
         """Packet dictionary"""

{fprime_gds-3.6.0 → fprime_gds-3.6.2a1}/src/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-3.6.0 → fprime_gds-3.6.2a1}/src/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
         }
 
 

{fprime_gds-3.6.0 → fprime_gds-3.6.2a1}/src/fprime_gds/flask/static/addons/chart-display/addon.js

@@ -197,12 +197,17 @@ Vue.component("chart-display", {
             if (this.selected == null || this.chart == null) {
                 return;
             }
-            // Get channel name assuming the string is in component.channel format.
+            // Get channel name assuming the string is in either of these format:
+            // - component.channel format for XML dictionaries
+            // - deployment.component.channel for JSON dictionaries
+            // Can't just slice by last '.' because channel name can include complex types
+            // which are in the form of 'component.channel.fieldName'
+            let SLICE_INDEX = _dictionaries.metadata.dictionary_type == "xml" ? 2 : 3;
             let channel_full_name = this.selected
                 .split(".")
-                .slice(0, 2)
+                .slice(0, SLICE_INDEX)
                 .join(".");
-            let serial_path = this.selected.split(".").slice(2).join(".");
+            let serial_path = this.selected.split(".").slice(SLICE_INDEX).join(".");
 
             // Filter channels down to the graphed channel
             let new_channels = channels.filter((channel) => {

{fprime_gds-3.6.0 → fprime_gds-3.6.2a1}/src/fprime_gds/flask/static/js/datastore.js

@@ -253,6 +253,7 @@ class DataStore {
             commands_by_id: Object.fromEntries(Object.values(_loader.endpoints["command-dict"].data.dictionary).map((value) => [value.id, value])),
             framework_version: _loader.endpoints["command-dict"].data.framework_version,
             project_version: _loader.endpoints["command-dict"].data.project_version,
+            metadata: _loader.endpoints["command-dict"].data.metadata,
         });
         // Setup channels object in preparation for updates. Channel object need to be well formed, even if blank,
         // because rendering of edit-views is still possible.

{fprime_gds-3.6.0 → fprime_gds-3.6.2a1}/src/fprime_gds/flask/static/js/json.js

@@ -30,7 +30,7 @@ class RegExLexer {
         // NaN token
         ["NAN", /^NaN/],
         // boolean token
-        ["BOOLEAN", /^(true)|(false)/],
+        ["BOOLEAN", /^(true)|^(false)/],
         // Open object token
         ["OPEN_OBJECT", /^\{/],
         // Close object token
@@ -55,6 +55,8 @@ class RegExLexer {
     static tokenize(original_string) {
         let tokens = [];
         let input_string = original_string;
+        let total_length = 0;
+        let last_token_type = "--NONE--"
         // Consume the whole string
         while (input_string !== "") {
             let matched_something = false;
@@ -62,18 +64,23 @@ class RegExLexer {
                 let match = token_matcher.exec(input_string)
 
                 // Token detected
-                if (match != null) {
+                if (match != null && match.index == 0 ) {
                     matched_something = true;
                     let matched = match[0];
                     tokens.push([token_type, matched]);
                     // Consume the string
                     input_string = input_string.substring(matched.length);
+                    total_length += matched.length;
+                    last_token_type = token_type;
                     break;
                 }
             }
             // Check for no token match
             if (!matched_something) {
-                throw SyntaxError("Failed to match valid token: '" + input_string.substring(0, 20) + "'...");
+                let say = "Failed to match valid token: '" + input_string.substring(0, 20);
+                say += "' Context: '" + original_string.substring(Math.max(total_length - 20, 0), total_length + 20);
+                say += "' Last token's type: " + last_token_type + ".";
+                throw SyntaxError(say);
             }
         }
         return tokens;

{fprime_gds-3.6.0 → fprime_gds-3.6.2a1}/src/fprime_gds.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: fprime-gds
-Version: 3.6.0
+Version: 3.6.2a1
 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-3.6.0 → fprime_gds-3.6.2a1}/src/fprime_gds.egg-info/SOURCES.txt

@@ -91,18 +91,14 @@ src/fprime_gds/common/history/ram.py
 src/fprime_gds/common/history/test.py
 src/fprime_gds/common/loaders/__init__.py
 src/fprime_gds/common/loaders/ch_json_loader.py
-src/fprime_gds/common/loaders/ch_py_loader.py
 src/fprime_gds/common/loaders/ch_xml_loader.py
 src/fprime_gds/common/loaders/cmd_json_loader.py
-src/fprime_gds/common/loaders/cmd_py_loader.py
 src/fprime_gds/common/loaders/cmd_xml_loader.py
 src/fprime_gds/common/loaders/dict_loader.py
 src/fprime_gds/common/loaders/event_json_loader.py
-src/fprime_gds/common/loaders/event_py_loader.py
 src/fprime_gds/common/loaders/event_xml_loader.py
 src/fprime_gds/common/loaders/json_loader.py
 src/fprime_gds/common/loaders/pkt_xml_loader.py
-src/fprime_gds/common/loaders/python_loader.py
 src/fprime_gds/common/loaders/xml_loader.py
 src/fprime_gds/common/logger/__init__.py
 src/fprime_gds/common/logger/data_logger.py