PyPI - fprime-gds - Versions diffs - 3.6.0__py3-none-any.whl → 3.6.2a1__py3-none-any.whl - Mend

fprime-gds 3.6.0py3-none-any.whl → 3.6.2a1py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

fprime_gds/common/loaders/json_loader.py CHANGED Viewed

@@ -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/common/pipeline/dictionaries.py CHANGED Viewed

@@ -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/flask/app.py CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/flask/static/addons/chart-display/addon.js CHANGED Viewed

@@ -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/flask/static/js/datastore.js CHANGED Viewed

@@ -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/flask/static/js/json.js CHANGED Viewed

@@ -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.dist-info → fprime_gds-3.6.2a1.dist-info}/METADATA RENAMED Viewed

@@ -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.dist-info → fprime_gds-3.6.2a1.dist-info}/RECORD RENAMED Viewed

@@ -58,18 +58,14 @@ fprime_gds/common/history/ram.py,sha256=ELNlyC6SmQJ-ZKD1NRi4H892tt1ppDNfz7R2c0UF
 fprime_gds/common/history/test.py,sha256=JMOlXPYtS9OTT1xb0GKn2YLI-0ESElbhvhb8usFatz0,5048
 fprime_gds/common/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/loaders/ch_json_loader.py,sha256=YF0nkDTlEJVZVTBWnjID8HFj8W9yq-hV2CkiyayCuhE,4079
-fprime_gds/common/loaders/ch_py_loader.py,sha256=NKJV03k9jOUB9vELVSXyCorIiUwbGx-MlatwOPsUAP8,2688
 fprime_gds/common/loaders/ch_xml_loader.py,sha256=wRXAC3GkUShvKtb89O5tY92BtKWOFYoJ7loOF7aL5v8,4093
 fprime_gds/common/loaders/cmd_json_loader.py,sha256=wcwAaalRHXntAb9m0EvX-fXNCj_ruITzItOvKKhXsGQ,3059
-fprime_gds/common/loaders/cmd_py_loader.py,sha256=6d_vMP0Vbpg2fnnV4qUtkC-WzlYkVm5kvTUABH-zp4E,2252
 fprime_gds/common/loaders/cmd_xml_loader.py,sha256=X-fCzLt1aCjqsDu-Exy2gSYDnh_TYi5rDnRpYT7tCZQ,2391
 fprime_gds/common/loaders/dict_loader.py,sha256=TasuICjsRYPWAsgmHGmsioxa8F7xmgAj9_UplzczylA,3990
 fprime_gds/common/loaders/event_json_loader.py,sha256=DPVJQ1wIY3r13rxTWrE9n7i6kSAF5m4jB-XRsxaRaDA,3572
-fprime_gds/common/loaders/event_py_loader.py,sha256=m4KlDl0mXn8ZQr-IfpUg0KaGIOJUErZkcIohlW9jNPc,2598
 fprime_gds/common/loaders/event_xml_loader.py,sha256=Q3Vm7ROTVgolSp5umkNMp0Eh95sir6ZAyAegrSjkiis,2875
-fprime_gds/common/loaders/json_loader.py,sha256=nXdu3eDI7_FSVbNmjbldFjReBQTxMLg14BpZlSGIAeM,8750
+fprime_gds/common/loaders/json_loader.py,sha256=YTvNkVRbaeDAKDs79J5RV7Z8zeO7x0_a8aIz5KLq9rA,9300
 fprime_gds/common/loaders/pkt_xml_loader.py,sha256=ZS4qchqQnIBx0Tw69ehP8yqm1g_uYSQzmnijR3FxqJg,4795
-fprime_gds/common/loaders/python_loader.py,sha256=FUNQbFy75bpqvss1JDu2UWZBMrtnMpFegM6mcglh42I,4858
 fprime_gds/common/loaders/xml_loader.py,sha256=8AlTTHddJbJqUr6St-zJI8CTqoPuCNtNoRBmdwCorcg,14820
 fprime_gds/common/logger/__init__.py,sha256=YBrr9An0fZbp4kvphRl8nLfolkdBqFAsSGzEZXQiH6g,1448
 fprime_gds/common/logger/data_logger.py,sha256=VjfhTGO1gGw954xNhSc0_zpw8JexCho5f8BlXDEYkL4,2505
@@ -82,7 +78,7 @@ fprime_gds/common/models/common/event.py,sha256=gSFrCJT9ZddGJfkf3fGCCqk0aMIQV-SN
 fprime_gds/common/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/parsers/seq_file_parser.py,sha256=6DZrA0jmt8IqsutfK7pdLtYn4oVHO593rWgAOH63yRg,9587
 fprime_gds/common/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/pipeline/dictionaries.py,sha256=j2vPt6P-jPzjlGOfEPwLrkPfQe-QhbjdjL91q4r_w38,7149
+fprime_gds/common/pipeline/dictionaries.py,sha256=T79xD30tbTupcDcfL2VDRw0YY-lUMN7xTjLYP7pStgU,6733
 fprime_gds/common/pipeline/encoding.py,sha256=rMCBoZOrnLctl4QNlbMro_QiCQ4sapWjtcoFGfvO-WM,6631
 fprime_gds/common/pipeline/files.py,sha256=J2zm0sucvImtmSnv0iUp5uTpvUO8nlmz2lUdMuMC5aM,2244
 fprime_gds/common/pipeline/histories.py,sha256=P1TN6mFOe9f5cZ_a-vCDN9o94vM7ax9n6fQogfUCce0,3548
@@ -115,7 +111,7 @@ fprime_gds/executables/run_deployment.py,sha256=01tI0JVONRkKaPPdfJS0Qt1mWm_7Wgf3
 fprime_gds/executables/tcpserver.py,sha256=KspVpu5YIuiWKOk5E6UDMKvqXYrRB1j9aX8CkMxysfw,17555
 fprime_gds/executables/utils.py,sha256=SbzXRe1p41qMPdifvPap5_4v0T42gZZ_Rs_OYfITd80,7626
 fprime_gds/flask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/flask/app.py,sha256=kJDCziri_BwZWKUszkR7u3RaNG_FWRzDkdCPsVDAtYM,6720
+fprime_gds/flask/app.py,sha256=2LTjx5MFP18ypYz_l80i4ijAWuxv7IVtmzCgCk0fBy8,6852
 fprime_gds/flask/channels.py,sha256=sOeL-UmWPh2hqYvqj81STpABLlPcjdPgkRwjd3Qx77k,735
 fprime_gds/flask/commands.py,sha256=62R3b0mnjc3_XpULpqJyUSvAcfOjAyZNifQ3wqHKO7s,3658
 fprime_gds/flask/components.py,sha256=a-eG8XJfSrqR8MIzIc9StwbNwxcBqkxYMEYq46S2Bmk,4176
@@ -125,7 +121,7 @@ fprime_gds/flask/events.py,sha256=BO9OUUwNDnRuOz4ZC6nFHMR7sJJ9P2P0xUxDluGd218,73
 fprime_gds/flask/json.py,sha256=PBljX3afJzyE_04DvZS4OEFOQW_ldVmfWiTYfxPZiGo,5888
 fprime_gds/flask/logs.py,sha256=CzHkXtv7_UG2b1c_z_cGIw-jJT088Sb7DggEB3c9D8U,1571
 fprime_gds/flask/requirements.txt,sha256=K6y8h0MJ66Zq9Pz2ZIR721wV0EX1mYDfom2gmBobxb4,20
-fprime_gds/flask/resource.py,sha256=h_zYGODshaInGQi2EpfU5ScDsQCR1RwqS8f7DzyuIOI,4131
+fprime_gds/flask/resource.py,sha256=1gMu2ITtm1YTTe0fksOQOk2OP4Y9gnyWAdf4B7Sst8A,4291
 fprime_gds/flask/sequence.py,sha256=1FfOFIUdWFX1qXjONAWm1vklPbyhkBYkuPow8RBt-yk,3554
 fprime_gds/flask/stats.py,sha256=i62envu9V6WpNsRD_mlhwzB_2dGUOCTf1XpyC5HApzg,1177
 fprime_gds/flask/updown.py,sha256=7za_zgOwQKHgm-3W1OBZqBgDLCmj7c0ziFEduhEuqdU,6176
@@ -143,7 +139,7 @@ fprime_gds/flask/static/addons/channel-render/addon.js,sha256=zAM8H_cVQp4qwXo_9c
 fprime_gds/flask/static/addons/channel-render/channel-render-template.js,sha256=wS8JOTUWp3OYwVYkBDTRJQjSiIdWFgmbnoMV4RukYj8,1966
 fprime_gds/flask/static/addons/channel-render/channel-render.js,sha256=hL0aGcnm8HEkhz0leKS7phxYFiG3vzWRznDX0qU4t6c,5080
 fprime_gds/flask/static/addons/chart-display/addon-templates.js,sha256=gyKy_uIh47s8Yia_xyeL81F-XQ3KpXT48IUo6Q_PwqI,6549
-fprime_gds/flask/static/addons/chart-display/addon.js,sha256=wEorz3UhLIyS6oqysUL6Kbq4m4UJPRzbTp7MZh1yVY8,9185
+fprime_gds/flask/static/addons/chart-display/addon.js,sha256=uYBnpK0VqlpOx1aRVr_Cv5AQ7dzGtjsrXHH1xWZtljo,9582
 fprime_gds/flask/static/addons/chart-display/config.js,sha256=df1HOg3D4v8623yIAZ0ipyWtj5Ip5tVQGyEjnREqObQ,3893
 fprime_gds/flask/static/addons/chart-display/sibling.js,sha256=2-k13yGpmF69kyBdAPR0tkO1kALQ1FnP3JmdJ01Lbes,3604
 fprime_gds/flask/static/addons/chart-display/modified-vendor/chartjs-plugin-streaming.js,sha256=zSynedxrMPIlkFT-tROg3n9EJ8tyf1vaguT-jv15klc,30243
@@ -182,9 +178,9 @@ fprime_gds/flask/static/img/error.svg,sha256=dJOAFEQ_DlLvJg-fBuBGDCBua8rbvSzmY3l
 fprime_gds/flask/static/img/logo.svg,sha256=czqCyVnhqFEw7qsKDMm63w959Pa77nYqY7GyoHVGcZ4,12470
 fprime_gds/flask/static/img/success.svg,sha256=wCfYG4cPfSCcsZ76JI4SwAJ-y62rahx9rJXyB-2qDIY,1757
 fprime_gds/flask/static/js/config.js,sha256=3CNrVmUtUGeiomAuoAE22w34r7wA-X0OtXN3JtLZYJ8,1066
-fprime_gds/flask/static/js/datastore.js,sha256=mx0ZaUq-Nlb2LParYfnhu0WMUH-JGKKKgRQD_nOcZNE,15437
+fprime_gds/flask/static/js/datastore.js,sha256=AAJKRQbcvQuS-4OScad5zBfYjHljDrjsL5RnTcXx39A,15508
 fprime_gds/flask/static/js/gds.js,sha256=OeDJrNmNA8hUPi8QIHP-s33MW_IYT3QIccxzL75MsjA,1297
-fprime_gds/flask/static/js/json.js,sha256=KUiuQBWKsSNA5TjU57azEIAzCb5zNsge7JEiR8c3i5M,12022
+fprime_gds/flask/static/js/json.js,sha256=kfwzTqoyLu_Feqcp9WEhDWpZ3lziwHy9LGkOg8PCo6s,12429
 fprime_gds/flask/static/js/loader.js,sha256=IbuJ7Jh70umyZog0iIupOuRGwc1tO5thT88jTW0XZc4,11414
 fprime_gds/flask/static/js/performance.js,sha256=fGBbK5anf5UB9iAr6rO4u9sCkrQGlOHHQLm1b3nvrvg,5359
 fprime_gds/flask/static/js/settings.js,sha256=Cfnn1ybZUOmsp48t_b23TDaHBRctvpD_h2ivBVKz6HM,1101
@@ -228,10 +224,10 @@ fprime_gds/flask/static/third-party/webfonts/fa-solid-900.woff2,sha256=mDS4KtJuK
 fprime_gds/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/plugin/definitions.py,sha256=5rHGSOrr62qRNVfX9bZIo4HDAKG62lKteNum9G40y3g,2347
 fprime_gds/plugin/system.py,sha256=uWd6DVW90Re0FoNMPNCx0cXXTJUdpgAAO0mtakzRNgk,8564
-fprime_gds-3.6.0.dist-info/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fprime_gds-3.6.0.dist-info/METADATA,sha256=3nRj3Lb0NjIJFRlzOGBlf3G9khk_Kk1XM_Wp5VFLlGM,24770
-fprime_gds-3.6.0.dist-info/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
-fprime_gds-3.6.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-fprime_gds-3.6.0.dist-info/entry_points.txt,sha256=oqUiO3xhJCR943jdU3zcxbqEvSXNeVgshk7dVaf_nGY,322
-fprime_gds-3.6.0.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
-fprime_gds-3.6.0.dist-info/RECORD,,
+fprime_gds-3.6.2a1.dist-info/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+fprime_gds-3.6.2a1.dist-info/METADATA,sha256=R_nYB3RORZOSvgkK0I7hoDumeAymhEUbrWEvQpKXpjE,24772
+fprime_gds-3.6.2a1.dist-info/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
+fprime_gds-3.6.2a1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+fprime_gds-3.6.2a1.dist-info/entry_points.txt,sha256=oqUiO3xhJCR943jdU3zcxbqEvSXNeVgshk7dVaf_nGY,322
+fprime_gds-3.6.2a1.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
+fprime_gds-3.6.2a1.dist-info/RECORD,,

{fprime_gds-3.6.0.dist-info → fprime_gds-3.6.2a1.dist-info}/WHEEL RENAMED Viewed

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any

fprime_gds/common/loaders/ch_py_loader.py DELETED Viewed

@@ -1,79 +0,0 @@
-"""
-@brief Loader class for importing python based channel dictionaries
-@date Created July 11, 2018
-@author R. Joseph Paetz
-@bug No known bugs
-"""
-from fprime_gds.common.templates.ch_template import ChTemplate
-# Custom Python Modules
-from .python_loader import PythonLoader
-class ChPyLoader(PythonLoader):
-    """Class to load python based telemetry channel dictionaries"""
-    # Field names in the python module files (used to construct dictionaries)
-    ID_FIELD = "ID"
-    NAME_FIELD = "NAME"
-    COMP_FIELD = "COMPONENT"
-    DESC_FIELD = "CHANNEL_DESCRIPTION"
-    TYPE_FIELD = "TYPE"
-    FMT_STR_FIELD = "FORMAT_STRING"
-    LOW_R_FIELD = "LOW_RED"
-    LOW_O_FIELD = "LOW_ORANGE"
-    LOW_Y_FIELD = "LOW_YELLOW"
-    HIGH_Y_FIELD = "HIGH_YELLOW"
-    HIGH_O_FIELD = "HIGH_ORANGE"
-    HIGH_R_FIELD = "HIGH_RED"
-    def construct_dicts(self, path):
-        """
-        Constructs and returns python dictionaries keyed on id and name
-        This function should not be called directly, instead, use
-        get_id_dict(path) and get_name_dict(path)
-        Args:
-            path: Path to the python module file dictionary to convert. This
-                  should be a directory. If using a regular fprime deployment,
-                  this should be a path to the events dictionary in your
-                  generated folder:
-                  ${GENERATED_FOLDER_LOCATION}/generated/${DEPLOYMENT}/channels
-        Returns:
-            A tuple with two channel dictionaries (python type dict):
-            (id_dict, name_dict). The keys should be the channels' id and
-            name fields respectively and the values should be ChTemplate
-            objects.
-        """
-        # We do need it sometimes, so if we don't always set it to true, we will need to pass an arg
-        module_dicts = self.read_dict(path, use_superpkg=True)
-        id_dict = {}
-        name_dict = {}
-        for ch_dict in module_dicts:
-            # Create a channel template object
-            ch_temp = ChTemplate(
-                ch_dict[self.ID_FIELD],
-                ch_dict[self.NAME_FIELD],
-                ch_dict[self.COMP_FIELD],
-                ch_dict[self.TYPE_FIELD],
-                ch_dict[self.FMT_STR_FIELD],
-                ch_dict[self.DESC_FIELD],
-                ch_dict[self.LOW_R_FIELD],
-                ch_dict[self.LOW_O_FIELD],
-                ch_dict[self.LOW_Y_FIELD],
-                ch_dict[self.HIGH_Y_FIELD],
-                ch_dict[self.HIGH_O_FIELD],
-                ch_dict[self.HIGH_R_FIELD],
-            )
-            id_dict[ch_dict[self.ID_FIELD]] = ch_temp
-            name_dict[ch_dict[self.NAME_FIELD]] = ch_temp
-        return id_dict, name_dict

fprime_gds/common/loaders/cmd_py_loader.py DELETED Viewed

@@ -1,66 +0,0 @@
-"""
-@brief Loader class for importing python based command dictionaries
-@date Created July 9, 2018
-@author R. Joseph Paetz
-@bug No known bugs
-"""
-from fprime_gds.common.templates import cmd_template
-# Custom Python Modules
-from . import python_loader
-class CmdPyLoader(python_loader.PythonLoader):
-    """Class to load python based command dictionaries"""
-    # Field names in the python module file dictionaries
-    COMPONENT_FIELD = "COMPONENT"
-    MNEMONIC_FIELD = "MNEMONIC"
-    OP_CODE_FIELD = "OP_CODE"
-    DESC_FIELD = "CMD_DESCRIPTION"
-    ARGS_FIELD = "ARGUMENTS"
-    def construct_dicts(self, path):
-        """
-        Constructs and returns python dictionaries keyed on id and name
-        This function should not be called directly, instead use
-        get_id_dict(path) and get_name_dict(path) defined in the base Loader
-        class. For the command dictionary, the op_code is treated as the ID and
-        the command mnemonic is treated as the name.
-        Args:
-            path: Path to the python module file dictionary to convert. This
-                  should be a directory. If using a regular fprime deployment,
-                  this should be a path to the events dictionary in your
-                  generated folder:
-                  ${GENERATED_FOLDER_LOCATION}/generated/${DEPLOYMENT}/events
-        Returns:
-            A tuple with two event dictionaries (python type dict):
-            (id_dict, name_dict). They should have keys of the id and name
-            fields respectively and the values for both should be event_template
-            objects.
-        """
-        module_dicts = self.read_dict(path, use_superpkg=True)
-        id_dict = {}
-        name_dict = {}
-        for cmd_dict in module_dicts:
-            # Create a cmd template object
-            cmd_temp = cmd_template.CmdTemplate(
-                cmd_dict[self.OP_CODE_FIELD],
-                cmd_dict[self.MNEMONIC_FIELD],
-                cmd_dict[self.COMPONENT_FIELD],
-                cmd_dict[self.ARGS_FIELD],
-                cmd_dict[self.DESC_FIELD],
-            )
-            id_dict[cmd_dict[self.OP_CODE_FIELD]] = cmd_temp
-            name_dict[cmd_dict[self.MNEMONIC_FIELD]] = cmd_temp
-        return id_dict, name_dict

fprime_gds/common/loaders/event_py_loader.py DELETED Viewed

@@ -1,75 +0,0 @@
-"""
-@brief Loader class for importing python based event dictionaries
-@date Created July 3, 2018
-@author R. Joseph Paetz
-@bug No known bugs
-"""
-from fprime.common.models.serialize.type_exceptions import TypeMismatchException
-from fprime_gds.common.templates import event_template
-from fprime_gds.common.utils.event_severity import EventSeverity
-# Custom Python Modules
-from . import python_loader
-class EventPyLoader(python_loader.PythonLoader):
-    """Class to load python based event dictionaries"""
-    # Field names in the python module file dictionaries
-    ID_FIELD = "ID"
-    NAME_FIELD = "NAME"
-    COMP_FIELD = "COMPONENT"
-    SEVERITY_FIELD = "SEVERITY"
-    FMT_STR_FIELD = "FORMAT_STRING"
-    DESC_FIELD = "EVENT_DESCRIPTION"
-    ARGS_FIELD = "ARGUMENTS"
-    def construct_dicts(self, path):
-        """
-        Constructs and returns python dictionaries keyed on id and name
-        This function should not be called directly, instead use
-        get_id_dict(path) and get_name_dict(path)
-        Args:
-            path: Path to the python module file dictionary to convert. This
-                  should be a directory. If using a regular fprime deployment,
-                  this should be a path to the events dictionary in your
-                  generated folder:
-                  ${GENERATED_FOLDER_LOCATION}/generated/${DEPLOYMENT}/events
-        Returns:
-            A tuple with two event dictionaries (python type dict):
-            (id_dict, name_dict). The keys should be the events' id and name
-            fields respectively and the values should be EventTemplate
-            objects.
-        """
-        module_dicts = self.read_dict(path, use_superpkg=True)
-        id_dict = {}
-        name_dict = {}
-        for event_dict in module_dicts:
-            try:
-                # Create an event template object
-                event_temp = event_template.EventTemplate(
-                    event_dict[self.ID_FIELD],
-                    event_dict[self.NAME_FIELD],
-                    event_dict[self.COMP_FIELD],
-                    event_dict[self.ARGS_FIELD],
-                    EventSeverity[event_dict[self.SEVERITY_FIELD]],
-                    event_dict[self.FMT_STR_FIELD],
-                    event_dict[self.DESC_FIELD],
-                )
-                id_dict[event_dict[self.ID_FIELD]] = event_temp
-                name_dict[event_dict[self.NAME_FIELD]] = event_temp
-            except TypeMismatchException as error:
-                print(f"Type mismatch: {error.getMsg()}")
-                raise error
-        return id_dict, name_dict

fprime_gds/common/loaders/python_loader.py DELETED Viewed

@@ -1,132 +0,0 @@
-"""
-@brief Base class for all loaders that load dictionaries of python fragments
-The PythonLoader class inherits from the DictLoader base class and is intended
-to be inherited by all loader classes that read dictionaries in the file system
-made up of multiple python file fragments.
-This Class only adds helper functions and thus does not overwrite any methods in
-in the base DictLoader class. Because of this, all dictionaries returned from
-this class will be empty.
-@date Created July 3, 2018
-@author R. Joseph Paetz
-@bug No known bugs
-"""
-import glob
-import importlib
-import os
-import sys
-from fprime_gds.common.data_types import exceptions
-# Custom Python Modules
-from . import dict_loader
-class PythonLoader(dict_loader.DictLoader):
-    """Class to help load python file based dictionaries"""
-    def read_dict(self, path, use_superpkg=False):
-        """
-        Reads all python modules at the given path and constructs a dict list
-        This function assumes that path is a directory containing many python
-        module files. Each module file has several fields with associated
-        values. This function reads each file and constructs a dictionary using
-        the fields and their values. These dictionaries are then compiled into
-        a list that is returned.
-        Args:
-            path: File Path to a folder containing python modules to load
-            use_superpkg: [Default=False] When true, modules will be imported
-                           using both the package and superpackage qualifiers
-                           (from A.B import C instead of from B import C). This
-                           allows multiple dictionaries with the same package
-                           name to be imported. This is especially important
-                           when trying to import dictionaries from multiple
-                           deployments.
-        Returns:
-            A list of dictionaries. Each dictionary represents one loaded module
-            and for keys has the names of the fields in the file and for values
-            has the values of those fields.
-        """
-        modules = self.import_modules(path, use_superpkg)
-        module_dicts = []
-        for module in modules:
-            # Create a dictionary for this module's fields
-            mod_dict = {
-                field: getattr(module, field)
-                for field in dir(module)
-                if field.find("__") != 0 # Verify it is not a hidden field (doesn't start with "__")
-            }
-            module_dicts.append(mod_dict)
-        return module_dicts
-    @staticmethod
-    def import_modules(path, use_superpkg):
-        """
-        Imports all modules in the given directory.
-        Args:
-            path: File Path to a folder containing python modules to load
-            use_superpkg: When true, modules will be imported
-                           using both the package and superpackage qualifiers
-                           (from A.B import C instead of from B import C). This
-                           allows multiple dictionaries with the same package
-                           name to be imported. This is especially important
-                           when trying to import dictionaries from multiple
-                           deployments.
-        Returns:
-            A list of module objects of all the newly imported modules
-        """
-        # Verify path is a directory
-        if not os.path.isdir(path):
-            raise exceptions.GseControllerUndefinedDirectoryException(path)
-        # Compute package and superpackage names
-        (superpkg_path, pkg) = os.path.split(path)
-        (rest_of_path, superpkg) = os.path.split(superpkg_path)
-        # Make sure the directory we are importing from is in the python path
-        if use_superpkg:
-            sys.path.append(rest_of_path)
-        else:
-            sys.path.append(superpkg_path)
-        # Make sure serializable directory is imported
-        sys.path.append(superpkg_path + os.sep + "serializable")
-        # Compute a list of all files to import
-        all_files = glob.glob(path + os.sep + "*.py")
-        module_files = []
-        for py_file in all_files:
-            (file_path, file_name) = os.path.split(py_file)
-            if file_name != "__init__.py":
-                module_files.append(file_name)
-        # Import modules
-        module_list = []
-        for mf in module_files:
-            # Strip off .py from name by splitting at '.' and taking the first
-            # string
-            mod_name = mf.split(".")[0]
-            if use_superpkg:
-                import_name = f"{superpkg}.{pkg}.{mod_name}"
-            else:
-                import_name = f"{pkg}.{mod_name}"
-            m = importlib.import_module(import_name)
-            module_list.append(m)
-        return module_list

{fprime_gds-3.6.0.dist-info → fprime_gds-3.6.2a1.dist-info}/LICENSE.txt RENAMED Viewed

File without changes

{fprime_gds-3.6.0.dist-info → fprime_gds-3.6.2a1.dist-info}/NOTICE.txt RENAMED Viewed

File without changes

{fprime_gds-3.6.0.dist-info → fprime_gds-3.6.2a1.dist-info}/entry_points.txt RENAMED Viewed

File without changes

{fprime_gds-3.6.0.dist-info → fprime_gds-3.6.2a1.dist-info}/top_level.txt RENAMED Viewed

File without changes

fprime-gds 3.6.0__py3-none-any.whl → 3.6.2a1__py3-none-any.whl

fprime-gds 3.6.0py3-none-any.whl → 3.6.2a1py3-none-any.whl