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

fprime_gds/common/data_types/cmd_data.py

@@ -131,9 +131,8 @@ class CmdData(sys_data.SysData):
         else:
             # The arguments are currently serializable objects which cannot be
             # used to fill in a format string. Convert them to values that can be
-            arg_val_list = [arg_obj.val for arg_obj in self.args]
-
-            arg_str = " ".join(str(arg_val_list))
+            arg_val_list = self.get_arg_vals()
+            arg_str = str(arg_val_list)
 
         if verbose and csv:
             return f"{time_str},{raw_time_str},{name},{self.id},{arg_str}"
@@ -149,13 +148,13 @@ class CmdData(sys_data.SysData):
         args = []
         for val, arg_tuple in zip(input_values, self.template.arguments):
             try:
-                _, _, arg_type = arg_tuple
+                arg_name, _, arg_type = arg_tuple
                 arg_value = arg_type()
                 self.convert_arg_value(val, arg_value)
                 args.append(arg_value)
                 errors.append("")
             except Exception as exc:
-                errors.append(str(exc))
+                errors.append(f"{arg_name}[{arg_type.__name__}]: {exc}")
         return args, errors
 
     @staticmethod

fprime_gds/common/loaders/json_loader.py

@@ -178,7 +178,10 @@ class JsonLoader(dict_loader.DictLoader):
             SerializableType: The constructed serializable type.
 
         """
-        struct_members = []
+        # Note on struct_members: the order of the members list matter when calling construct_type() below.
+        # It should be ordered by incrementing index which corresponds to the order in the FPP declaration
+        # The JSON dictionary ordering is not guaranteed, so we use a dict() to sort by index below.
+        struct_members = {}
         for name, member_dict in qualified_type.get("members").items():
             member_type_dict = member_dict["type"]
             member_type_obj = self.parse_type(member_type_dict)
@@ -197,11 +200,17 @@ class JsonLoader(dict_loader.DictLoader):
                 member_type_obj.FORMAT if hasattr(member_type_obj, "FORMAT") else "{}"
             )
             description = member_type_dict.get("annotation", "")
-            struct_members.append((name, member_type_obj, fmt_str, description))
+            member_index = member_dict["index"]
+            if member_index in struct_members:
+                raise KeyError(
+                    f"Invalid dictionary: Duplicate index {member_index} in serializable type {type_name}"
+                )
+            struct_members[member_index] = (name, member_type_obj, fmt_str, description)
 
+        # Construct the serializable type with list of members sorted by index
         ser_type = SerializableType.construct_type(
             type_name,
-            struct_members,
+            [struct_members[i] for i in sorted(struct_members.keys())],
         )
         self.parsed_types[type_name] = ser_type
         return ser_type

fprime_gds/common/transport.py

@@ -241,7 +241,7 @@ class ThreadedTCPSocketClient(ThreadedTransportClient):
         assert self.dest is not None, "Cannot send data before connect call"
         self.sock.send(b"A5A5 %s %s" % (self.dest, data))
 
-    def recv(self, timeout=100):
+    def recv(self, timeout=0.1):
         """Receives data from the threaded tcp server
 
         Receives raw data from the threaded tcp server. This data is expected to have no headers and will be passed as

fprime_gds/flask/commands.py

@@ -49,7 +49,7 @@ class CommandArgumentsInvalidException(werkzeug.exceptions.BadRequest):
     """Command arguments failed to validate properly"""
 
     def __init__(self, errors):
-        super().__init__("Failed to validate all arguments")
+        super().__init__(f"Failed to validate all arguments: {', '.join(errors)}")
         self.args = errors
 
 

fprime_gds/flask/static/addons/commanding/arguments.js

@@ -74,7 +74,7 @@ export function command_argument_assignment_helper(argument, squashed_argument_v
         command_argument_array_serializable_assignment_helper(argument, squashed_argument_value);
     } else {
         let is_not_string = typeof(argument.type.MAX_LENGTH) === "undefined";
-        argument.value = (is_not_string && (squashed_argument_value === FILL_NEEDED)) ? null : squashed_argument_value;
+        argument.value = (is_not_string && (squashed_argument_value === FILL_NEEDED)) ? null : squashed_argument_value.toString();
     }
 }
 
@@ -119,7 +119,21 @@ export function squashify_argument(argument) {
             let field = argument.type.MEMBER_LIST[i][0];
             value[field] = squashify_argument(argument.value[field]);
         }
-    } else if (["U64Type", "U32Type", "U16Type", "U8Type"].indexOf(argument.type.name) != -1) {
+    } else if (["U64Type"].indexOf(argument.type.name) !== -1) {
+        if (argument.value.startsWith("0x")) {
+            // Hexadecimal
+            value = BigInt(argument.value, 16);
+        } else if (argument.value.startsWith("0b")) {
+            // Binary
+            value = BigInt(argument.value.slice(2), 2);
+        } else if (argument.value.startsWith("0o")) {
+            // Octal
+            value = BigInt(argument.value.slice(2), 8);
+        } else {
+            // Decimal
+            value = BigInt(argument.value, 10);
+        }
+    } else if (["U32Type", "U16Type", "U8Type"].indexOf(argument.type.name) !== -1) {
         if (argument.value.startsWith("0x")) {
             // Hexadecimal
             value = parseInt(argument.value, 16);
@@ -134,10 +148,13 @@ export function squashify_argument(argument) {
             value = parseInt(argument.value, 10);
         }
     }
-    else if (["I64Type", "I32Type", "I16Type", "I8Type"].indexOf(argument.type.name) != -1) {
+    else if (["I64Type"].indexOf(argument.type.name) !== -1) {
+        value = BigInt(argument.value, 10);
+    }
+    else if (["I32Type", "I16Type", "I8Type"].indexOf(argument.type.name) !== -1) {
         value = parseInt(argument.value, 10);
     }
-    else if (["F64Type", "F32Type"].indexOf(argument.type.name) != -1) {
+    else if (["F64Type", "F32Type"].indexOf(argument.type.name) !== -1) {
         value = parseFloat(argument.value);
     }
     else if (argument.type.name == "BoolType") {
@@ -160,22 +177,35 @@ export function squashify_argument(argument) {
  * @returns: string to display
  */
 export function argument_display_string(argument) {
-    // Base assignment of the value
-    let string = `${(argument.value == null || argument.value === "") ? FILL_NEEDED: argument.value}`;
-
-    if (argument.type.LENGTH) {
-        string = `[${argument.value.map((argument) => argument_display_string(argument)).join(", ")}]`;
-    } else if (argument.type.MEMBER_LIST) {
-        let fields = [];
-        for (let i = 0; i < argument.type.MEMBER_LIST.length; i++) {
-            let field = argument.type.MEMBER_LIST[i][0];
-            fields.push(`${field}: ${argument_display_string(argument.value[field])}`);
+    let string = FILL_NEEDED;
+    try {
+        // Check for array
+        if (argument.type.LENGTH) {
+            string = `[${argument.value.map((argument) => argument_display_string(argument)).join(", ")}]`;
+        }
+        // Serializable
+        else if (argument.type.MEMBER_LIST) {
+            let fields = [];
+            for (let i = 0; i < argument.type.MEMBER_LIST.length; i++) {
+                let field = argument.type.MEMBER_LIST[i][0];
+                fields.push(`${field}: ${argument_display_string(argument.value[field])}`);
+            }
+            string = `{${fields.join(", ")}}`
+        }
+        // String type
+        else if (argument.type.MAX_LENGTH) {
+            let value = (argument.value == null) ? "" : argument.value;
+            value = value.replace(/"/g, '\\\"');
+            string = `"${value}"`
+        }
+        // Unassigned values
+        else if (argument.value == null || argument.value === "") {
+            string = FILL_NEEDED;
+        } else {
+            string = squashify_argument(argument);
         }
-        string = `{${fields.join(", ")}}`
-    } else if (argument.type.MAX_LENGTH) {
-        let value = (argument.value == null) ? "" : argument.value;
-        value = value.replace(/"/g, '\\\"');
-        string = `"${value}"`
+    } catch (e) {
+        string = FILL_NEEDED;
     }
     return string;
 }
@@ -291,7 +321,7 @@ Vue.component("command-scalar-argument", {
                 return ["text", "0[bB][01]+|0[oO][0-7]+|0[xX][0-9a-fA-F]+|[1-9]\\d*|0", ""];
             }
             else if (["I64Type", "I32Type", "I16Type", "I8Type"].indexOf(this.argument.type.name) != -1) {
-                return ["number", null, "1"];
+                return ["text", "-?[1-9]\\d*|0", ""];
             }
             else if (["F64Type", "F32Type"].indexOf(this.argument.type.name) != -1) {
                 return ["number", null, "any"];

fprime_gds/flask/static/addons/commanding/command-history.js

@@ -10,7 +10,8 @@ import {command_argument_assignment_helper} from "./arguments.js";
 import {listExistsAndItemNameNotInList, timeToString} from "../../js/vue-support/utils.js";
 import {command_history_template} from "./command-history-template.js";
 import {command_display_string} from "./command-string.js";
-
+import { SaferParser } from "../../js/json.js";
+SaferParser.register();
 
 /**
  * command-history:
@@ -103,27 +104,7 @@ Vue.component("command-history", {
             // Can only set command if it is a child of a command input
             if (this.$parent.selectCmd) {
                 // command-input expects an array of strings as arguments
-                this.$parent.selectCmd(cmd.full_name, this.preprocess_args(cmd.args));
-            }
-        },
-        /**
-         * Process the arguments for a command. If the argument is (or contains) a number, it
-         * is converted to a string. Other types that should be pre-processed can be added here.
-         * 
-         * @param {*} args 
-         * @returns args processed for command input (numbers converted to strings)
-         */
-        preprocess_args(args) {
-            if (Array.isArray(args)) {
-                return args.map(el => this.preprocess_args(el));
-            } else if (typeof args === 'object' && args !== null) {
-                return Object.fromEntries(
-                    Object.entries(args).map(([key, value]) => [key, this.preprocess_args(value)])
-                );
-            } else if (typeof args === 'number') {
-                return args.toString();
-            } else {
-                return args;
+                this.$parent.selectCmd(cmd.full_name, cmd.args);
             }
         }
     }

fprime_gds/flask/static/addons/commanding/command-input.js

@@ -15,6 +15,8 @@ import {
 } from "../../addons/commanding/arguments.js";
 import {_settings} from "../../js/settings.js";
 import {command_input_template} from "./command-input-template.js";
+import { SaferParser } from "../../js/json.js";
+SaferParser.register();
 
 /**
  * This helper will help assign command and values in a safe manner by searching the command store, finding a reference,
@@ -38,6 +40,7 @@ function command_assignment_helper(desired_command_name, desired_command_args, p
         return null;
     }
     let selected = _datastore.commands[command_name];
+
     // Set arguments here
     for (let i = 0; i < selected.args.length; i++) {
         let assign_value = (desired_command_args.length > i)? desired_command_args[i] : null;
@@ -147,6 +150,7 @@ Vue.component("command-input", {
          * command reaches the ground system.
          */
         sendCommand() {
+
             // Validate the command before sending anything
             if (!this.validate()) {
                 return;
@@ -158,8 +162,9 @@ Vue.component("command-input", {
             let _self = this;
             _self.active = true;
             let command = this.selected;
+            let squashed_args = command.args.map(serialize_arg);
             this.loader.load("/commands/" + command.full_name, "PUT",
-                {"key":0xfeedcafe, "arguments": command.args.map(serialize_arg)})
+                {"key":0xfeedcafe, "arguments": squashed_args})
                 .then(function() {
                     _self.active = false;
                     // Clear errors, as there is not a problem further

fprime_gds/flask/static/addons/commanding/command-string-template.js

@@ -3,7 +3,8 @@
  *
  * Contains the templates used to render the command string input box.
  */
-export let COMMAND_FORMAT_SPEC = "FULL_COMMAND_NAME[[[, ARG1], ARG2], ...]";
+export let COMMAND_FORMAT_SPEC = "FULL_COMMAND_NAME[[[, ARG1], ARG2], ...] " +
+    "where ARGN is a decimal number, quoted string, or an enumerated constant";
 
 export let command_string_template = `
 <div class="fp-flex-repeater">

fprime_gds/flask/static/addons/commanding/command-string.js

@@ -10,6 +10,8 @@ import {
     command_string_template
 } from "./command-string-template.js";
 import {argument_display_string, FILL_NEEDED} from "./arguments.js"
+import {SaferParser} from "../../js/json.js";
+SaferParser.register();
 
 let STRING_PREPROCESSOR = new RegExp(`(?:"((?:[^\"]|\\\")*)")|([a-zA-Z_][a-zA-Z_0-9.]*)|(${FILL_NEEDED})`, "g");
 
@@ -61,7 +63,9 @@ Vue.component("command-text", {
                 } catch (e) {
                     // JSON parsing exceptions
                     if (e instanceof SyntaxError) {
-                        this.error = `Expected command string of the form: ${COMMAND_FORMAT_SPEC}`;
+                        this.error = `Expected command string of the form: ${COMMAND_FORMAT_SPEC}.`;
+                    } else {
+                        throw e;
                     }
                 }
             }

fprime_gds/flask/static/addons/sequencer/addon.js

@@ -16,6 +16,8 @@ import {_datastore} from "../../js/datastore.js";
 import {basicSetup, EditorState, EditorView, linter} from "./third/code-mirror.es.js"
 import {sequenceLanguageSupport} from "./autocomplete.js"
 import {processResponse} from "./lint.js";
+import { SaferParser } from "../../js/json.js";
+SaferParser.register();
 
 /**
  * Sequence sender function used to uplink the sequence and return a promise of how to handle the server's return.

fprime_gds/flask/static/js/json.js

@@ -0,0 +1,333 @@
+/**
+ * json.js:
+ *
+ * Contains specialized JSON parser to handle non-standard JSON values from the JavaScript perspective. These values
+ * are legal in Python and scala, but not in JavaScript. This parser will safely handle these values.
+ *
+ * @author mstarch
+ */
+
+
+/**
+ * Lexer for JSON built using JSON
+ */
+class RegExLexer {
+    static TOKEN_EXPRESSIONS = new Map([
+        // String tokens: " then
+        //    any number of:
+        //        not a quote or \
+        //        \ followed by not a quote
+        //        even number of \
+        //        odd number of \ then " (escaped quotation)
+        //    then even number of \ then " (terminating non-escaped ")
+        ["STRING", /^"([^"\\]|(\\[^"\\])|((\\\\)*)|(\\(\\\\)*)")*(?!\\(\\\\)*)"/],
+        // Floating point tokens
+        ["NUMBER", /^-?\d+(\.\d+)?([eE][+\-]?\d+)?/],
+        // Infinity token
+        ["INFINITY", /^-?Infinity/],
+        // Null token
+        ["NULL", /^null/],
+        // NaN token
+        ["NAN", /^NaN/],
+        // boolean token
+        ["BOOLEAN", /^(true)|(false)/],
+        // Open object token
+        ["OPEN_OBJECT", /^\{/],
+        // Close object token
+        ["CLOSE_OBJECT", /^}/],
+        // Field separator token
+        ["FIELD_SEPARATOR", /^,/],
+        // Open list token
+        ["OPEN_ARRAY", /^\[/],
+        // Close a list token
+        ["CLOSE_ARRAY", /^]/],
+        // Key Value Separator
+        ["VALUE_SEPARATOR", /^:/],
+        // Any amount of whitespace is an implicit token
+        ["WHITESPACE", /^\s+/]
+    ]);
+
+    /**
+     * Tokenize the input string based on JSON tokens.
+     * @param input_string: input string to tokenize
+     * @return {*[]}: list of tokens in-order
+     */
+    static tokenize(original_string) {
+        let tokens = [];
+        let input_string = original_string;
+        // Consume the whole string
+        while (input_string !== "") {
+            let matched_something = false;
+            for (let [token_type, token_matcher] of  RegExLexer.TOKEN_EXPRESSIONS.entries()) {
+                let match = token_matcher.exec(input_string)
+
+                // Token detected
+                if (match != null) {
+                    matched_something = true;
+                    let matched = match[0];
+                    tokens.push([token_type, matched]);
+                    // Consume the string
+                    input_string = input_string.substring(matched.length);
+                    break;
+                }
+            }
+            // Check for no token match
+            if (!matched_something) {
+                throw SyntaxError("Failed to match valid token: '" + input_string.substring(0, 20) + "'...");
+            }
+        }
+        return tokens;
+    }
+}
+
+/**
+ * Helper to determine if value is a string
+ * @param value: value to check.
+ * @return {boolean}: true if string, false otherwise
+ */
+function isString(value) {
+    return value instanceof String || typeof value === 'string';
+}
+
+/**
+ * Helper to determine if value is a function
+ * @param value: value to check
+ * @return {boolean}: true if function, false otherwise
+ */
+function isFunction(value) {
+    return value instanceof Function || typeof value == "function";
+}
+
+/**
+ * Convert a string to a number
+ * @param value: value to convert
+ * @return {bigint|number}: number to return
+ */
+function stringToNumber(value) {
+    value = value.trim(); // Should be unnecessary
+    // Process floats (containing . e or E)
+    if (value.search(/[.eE]/) !== -1) {
+        return Number.parseFloat(value);
+    }
+    let number_value = Number.parseInt(value);
+    // When the big and normal numbers match, then return the normal number
+    if (value !== number_value.toString()) {
+        return BigInt(value);
+    }
+    return number_value;
+}
+
+/**
+ * Parser to safely handle potential JSON object from Python. Python can produce some non-standard values (infinities,
+ * NaNs, etc.) These values then break on the JS Javascript parser. To localize these faults, they are replaced before
+ * processing with strings and then formally set during parsing.
+ *
+ * This is done by looking for tokens in unquoted text and replacing them with string representations.
+ * 
+ * This parser will handle:
+ * - -Infinity
+ * - Infinity
+ * - NaN
+ * - null
+ * - BigInt
+ */
+export class SaferParser {
+    static CONVERSION_KEY = "fprime{replacement";
+
+    static CONVERSION_MAP = new Map([
+        ["INFINITY", (value) => (value[0] === "-") ? -Infinity : Infinity],
+        ["NAN", NaN],
+        ["NULL", null],
+        ["NUMBER", stringToNumber]
+    ]);
+
+    static STRINGIFY_TOKENS = [
+        Infinity,
+        -Infinity,
+        NaN,
+        "number",
+        "bigint",
+        null
+    ];
+
+
+    // Store the language variants the first time
+    static language_parse = JSON.parse;
+    static language_stringify = JSON.stringify;
+
+    /**
+     * @brief safely process F Prime JSON syntax
+     *
+     * Parse method that will replace JSON.parse. This method pre-processes the string data incoming (to be transformed
+     * into JavaScript objects) for detection of entities not expressible in JavaScript's JSON implementation. This will
+     * replace those entities with a JSON flag object.
+     *
+     * Then the data is processed by the JavaScript built-in JSON parser (now done safely).  The reviver function will
+     * safely revive the flag objects into JavaScript representations of those object.
+     *
+     * Handles:
+     * 1. BigInts
+     * 2. Inf/-Inf
+     * 3. NaN
+     * 4. null
+     *
+     * @param json_string: JSON string data containing potentially bad values
+     * @param reviver: reviver function to be combined with our reviver
+     * @return {{}}: Javascript Object representation of data safely represented in JavaScript types
+     */
+    static parse(json_string, reviver) {
+        let converted_data = SaferParser.preprocess(json_string);
+        // Set up a composite reviver of the one passed in and ours
+        let input_reviver = reviver || ((key, value) => value);
+        let full_reviver = (key, value) => input_reviver(key, SaferParser.reviver(key, value));
+        try {
+            let language_parsed = SaferParser.language_parse(converted_data, full_reviver);
+            return language_parsed;
+        } catch (e) {
+            let message = e.toString();
+            const matcher = /line (\d+) column (\d+)/
+
+            // Process the match
+            let snippet = "";
+            let match = message.match(matcher);
+            if (match != null) {
+                let lines = converted_data.split("\n");
+                let line = lines[Number.parseInt(match[1]) - 1]
+                snippet = line.substring(Number.parseInt(match[2]) - 6, Number.parseInt(match[2]) + 5);
+                message += ". Offending snippet: " + snippet;
+                throw new SyntaxError(message);
+            }
+            throw e;
+        }
+    }
+
+    /**
+     * @brief safely write the F Prime JSON syntax
+     *
+     * Stringify method that will replace JSON.stringify. This method post-processes the string data outgoing from
+     * JavaScript's built-in stringify method to replace flag-objects with the correct F Prime representation in
+     * JavaScript.
+     *
+     * This uses the javascript stringify handler method to pre-convert unsupported types into a flag object. This flag
+     * object is post-converted into a normal string after JSON.stringify has done its best.
+     *
+     * Handles:
+     * 1. BigInts
+     * 2. Inf/-Inf
+     * 3. NaN
+     * 4. null
+     *
+     * @param data: data object to stringify
+     * @param replacer: replacer Array or Function
+     * @param space: space for passing into JSON.stringify
+     * @return {{}}: JSON string using JSON support for big-ints Int/-Inf, NaN and null.
+     */
+    static stringify(data, replacer, space) {
+        let full_replacer = (key, value) => {
+            // Handle array case for excluded field
+            if (Array.isArray(replacer) && replacer.indexOf(key) === -1) {
+                return undefined;
+            }
+            // Run input replacer first
+            else if (isFunction(replacer)) {
+                value = replacer(key, value);
+            }
+            // Then run our safe replacer
+            let replaced = SaferParser.replaceFromObject(key, value);
+            return replaced;
+        };
+        // Stringify JSON using built-in JSON parser and the special replacer
+        let json_string = SaferParser.language_stringify(data, full_replacer, space);
+        // Post-process JSON string to rework JSON into the wider specification
+        let post_replace =  SaferParser.postReplacer(json_string);
+        return post_replace
+    }
+
+    /**
+     * Get replacement object from a JavaScript type
+     * @param _: unused
+     * @param value: value to replace
+     */
+    static replaceFromObject(_, value) {
+        for (let i = 0; i < SaferParser.STRINGIFY_TOKENS.length; i++) {
+            let replacer_type = SaferParser.STRINGIFY_TOKENS[i];
+            let mapper_is_string = isString(replacer_type);
+            if ((!mapper_is_string && value === replacer_type) || (mapper_is_string && typeof value === replacer_type)) {
+                let replace_object = {};
+                replace_object[SaferParser.CONVERSION_KEY] = (value == null) ? "null" : value.toString();
+                return replace_object;
+            }
+        }
+        return value;
+    }
+
+    /**
+     * Replace JSON notation for fprime-replacement objects with the wider JSON specification
+     *
+     * Replace {"fprime-replacement: "some value"} with <some value> restoring the full JSON specification for items not
+     * supported by JavaScript.
+     *
+     * @param json_string: JSON string to rework
+     * @return reworked JSON string
+     */
+    static postReplacer(json_string) {
+        return json_string.replace(/\{\s*"fprime\{replacement"\s*:\s*"([^"]+)"\s*}/sg, "$1");
+    }
+
+    /**
+     * Apply process function to raw json string only for data that is not qu
+     * @param json_string: JSON string to preprocess
+     * @return {string}
+     */
+    static preprocess(json_string) {
+        const CONVERSION_KEYS = Array.from(SaferParser.CONVERSION_MAP.keys());
+        let tokens = RegExLexer.tokenize(json_string);
+        let converted_text = tokens.map(
+            ([token_type, token_text]) => {
+                if (CONVERSION_KEYS.indexOf(token_type) !== -1) {
+                    let replacement_object = {};
+                    replacement_object[SaferParser.CONVERSION_KEY] = token_type;
+                    replacement_object["value"] = token_text;
+                    return SaferParser.language_stringify(replacement_object)
+                }
+                return token_text;
+        });
+        return converted_text.join("");
+    }
+
+    /**
+     * Inverse of convert removing string and replacing back invalid JSON tokens.
+     * @param key: JSON key
+     * @param value: JSON value search for the converted value.
+     * @return {*}: reverted value or value
+     */
+    static reviver(key, value) {
+        // Look for fprime-replacement and quickly abort if not there
+        let replacement_type = value[SaferParser.CONVERSION_KEY];
+        if (typeof replacement_type === "undefined") {
+            return value;
+        }
+        let string_value = value["value"];
+        let replacer = SaferParser.CONVERSION_MAP.get(replacement_type);
+        return isFunction(replacer) ? replacer(string_value) : replacer;
+    }
+
+     /**
+     * @brief force all calls to JSON.parse and JSON.stringify to use the SafeParser
+     */
+    static register() {
+        // Override the singleton
+        JSON.parse = SaferParser.parse;
+        JSON.stringify = SaferParser.stringify;
+    }
+
+    /**
+     * @brief remove the JSON.parse safe override
+     */
+    static deregister() {
+        JSON.parse = SaferParser.language_parse;
+        JSON.stringify = SaferParser.language_stringify;
+    }
+}
+// Take over all JSON.parse and JSON.stringify calls
+SaferParser.register();

fprime_gds/flask/static/js/loader.js

@@ -13,7 +13,8 @@
  */
 import {config} from "./config.js";
 import {_settings} from "./settings.js";
-import {_validator} from "./validate.js";
+import {SaferParser} from "./json.js";
+SaferParser.register();
 
 /**
  * Function allowing for the saving of some data to a downloadable file.
@@ -50,118 +51,6 @@ export function loadTextFileInputData(event) {
     });
 }
 
-/**
- * Parser to safely handle potential JSON object from Python. Python can produce some non-standard values (infinities,
- * NaNs, etc.) These values then break on the JS Javascript parser. To localize these faults, they are replaced before
- * processing with strings and then formally set during parsing.
- *
- * This is done by looking for tokens in unquoted text and replacing them with string representations.
- *
- */
-class SaferParser {
-    /**
-     * Set up the parser
-     */
-    constructor() {
-        this.STATES = {
-            UNQUOTED: 0,
-            QUOTED: 1
-        };
-        this.FLAG = "-_-您好"; // Extended character usage make collisions less-likely
-        this.MAPPINGS = [
-            ["-Infinity", this.FLAG + "-inf", -Infinity],
-            ["Infinity", this.FLAG + "inf", Infinity],
-            ["NaN", this.FLAG + "nan", NaN],
-            ["null", this.FLAG + "null", null]
-        ];
-        this.state = this.STATES.UNQUOTED;
-    }
-
-    /**
-     * Parse method that will replace JSON.parse. This handles known bad cases and also prints better error messages
-     * including the working snippets of text.
-     * @param rawData: string data
-     * @return {{}|any}: Javascript Object representation of data.
-     */
-    parse(rawData) {
-        let converted_data = this.convert(rawData);
-        try {
-            return JSON.parse(converted_data, this.revert.bind(this));
-        } catch (e) {
-            let message = e.toString();
-            const matcher = /line (\d+) column (\d+)/
-
-            // Process the match
-            let snippet = "";
-            let match = message.match(matcher);
-            if (match != null) {
-                let lines = converted_data.split("\n");
-                let line = lines[Number.parseInt(match[1]) - 1]
-                snippet = line.substring(Number.parseInt(match[2]) - 6, Number.parseInt(match[2]) + 5);
-                message += ". Offending snippet: " + snippet;
-            }
-            _validator.updateErrors([message]);
-        }
-        return {};
-    }
-
-    /**
-     * Convert data from invalid form to strings.
-     * @param rawData: raw data including potentially invalid data
-     * @return {string}: string data in correct JSON format
-     */
-    convert(rawData) {
-        let unprocessed = rawData;
-        let transformed_data = "";
-
-        while (unprocessed.length > 0) {
-            let next_quote = unprocessed.indexOf("\"");
-            let section = (next_quote !== -1) ? unprocessed.substring(0, next_quote + 1) : unprocessed.substring(0);
-            unprocessed = unprocessed.substring(section.length);
-            transformed_data += this.processChunk(section);
-            this.state = (this.state === this.STATES.QUOTED) ? this.STATES.UNQUOTED : this.STATES.QUOTED;
-        }
-        return transformed_data;
-    }
-
-    /**
-     * Inverse of convert removing string and replacing back invalid JSON tokens.
-     * @param key: JSON key
-     * @param value: JSON value search for the converted value.
-     * @return {*}: reverted value or value
-     */
-    revert(key, value) {
-        for (let i = 0; i < this.MAPPINGS.length; i++) {
-            if ((this.MAPPINGS[i][1]) === value) {
-                return this.MAPPINGS[i][2];
-            }
-        }
-        return value;
-    }
-
-    /**
-     * Process a section of the JSON string looking for values to convert. This is intended to handle a section of
-     * quoted or unquoted text but should never handle quoted and unquoted data in one call.
-     * @param section: section of the data
-     * @return {*}: converted data
-     */
-    processChunk(section) {
-        // Replaces all the above mappings with a flagged value
-        let replace_all = (section) => {
-            for (let i = 0; i < this.MAPPINGS.length; i++) {
-                section = section.replace(this.MAPPINGS[i][0], "\"" + this.MAPPINGS[i][1] + "\"");
-            }
-            return section;
-        }
-
-        // When out of quoted space,
-        if (this.state === this.STATES.UNQUOTED) {
-            return replace_all(section);
-        }
-        return section;
-    }
-}
-
 /**
  * Loader:
  *
@@ -308,7 +197,7 @@ class Loader {
                 if (this.readyState === 4 && this.status === 200 && raw) {
                     resolve(this.responseText);
                 } else if (this.readyState === 4 && this.status === 200) {
-                    let dataObj = new SaferParser().parse(this.responseText);
+                    let dataObj = JSON.parse(this.responseText);
                     resolve(dataObj);
                 } else if(this.readyState === 4) {
                     reject(this.responseText);

{fprime_gds-3.5.2a1.dist-info → fprime_gds-3.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: fprime-gds
-Version: 3.5.2a1
+Version: 3.6.0
 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.5.2a1.dist-info → fprime_gds-3.6.0.dist-info}/RECORD

@@ -3,7 +3,7 @@ fprime_gds/__init__.py,sha256=y2ljhCEHnvyfSDvXIEgBGIk8oHjjjjCWFxfddOGeYFk,115
 fprime_gds/version.py,sha256=dlUlfOKTsGaqz_L7TjhCVC-Vanx5cK67kdZlqcHCM8M,395
 fprime_gds/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/handlers.py,sha256=t2-st-C3Z486kfcu2cpf-wHJQmpaaHQYj1dyXJEMmSU,2632
-fprime_gds/common/transport.py,sha256=y9HiupzsCRF5_JFMMtMWQxcEYPvPuxX1P_oBeqosKR0,10565
+fprime_gds/common/transport.py,sha256=uYXWkM8TYEYz1vfY4AEn0PF8Gu4tkYmJ5t4w1YY1yW8,10565
 fprime_gds/common/zmq_transport.py,sha256=E_iBZ5sA4JKB99MWSOM6XnPrO-mbFyRvD9eQp9te6-Y,12397
 fprime_gds/common/communication/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/communication/checksum.py,sha256=f6W0Tr68U-XGnFmysMqsFzoGYZVE8clKf-VIJja_1YM,741
@@ -17,7 +17,7 @@ fprime_gds/common/communication/adapters/uart.py,sha256=6SrN42ShVjwNubFg-1YrO09o
 fprime_gds/common/controllers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/data_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/data_types/ch_data.py,sha256=RP9zSyzNcH0nJ3MYyW_IATnmnHYZ6d0KmoJUJantdBI,6111
-fprime_gds/common/data_types/cmd_data.py,sha256=nC6qhtBvqSgEueDn075XA_3dAwjnPHpLwhElhdMG4QQ,7080
+fprime_gds/common/data_types/cmd_data.py,sha256=hsNJHCPKfqDRx4EzZ5DjobyD-oFlcXEWBS8NbDNfqgk,7090
 fprime_gds/common/data_types/event_data.py,sha256=7_vA6Xwvs9kK1-xJzc6lwO_TtUeWdI7p29B6QJNMc40,5372
 fprime_gds/common/data_types/exceptions.py,sha256=C16L2lofigH8UmnsYO_fuY6yR20U-ckRcl14HZjQlJc,1054
 fprime_gds/common/data_types/file_data.py,sha256=4_G9kf4ThC5NzkxnKa0xNYBdi8UDvZg8f5Vw0DdGIBE,3904
@@ -67,7 +67,7 @@ fprime_gds/common/loaders/dict_loader.py,sha256=TasuICjsRYPWAsgmHGmsioxa8F7xmgAj
 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=afD873WyIsbzWTz4SzydLfAKD2yFirj-l79xb4g_TBk,8051
+fprime_gds/common/loaders/json_loader.py,sha256=nXdu3eDI7_FSVbNmjbldFjReBQTxMLg14BpZlSGIAeM,8750
 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
@@ -117,7 +117,7 @@ fprime_gds/executables/utils.py,sha256=SbzXRe1p41qMPdifvPap5_4v0T42gZZ_Rs_OYfITd
 fprime_gds/flask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/flask/app.py,sha256=kJDCziri_BwZWKUszkR7u3RaNG_FWRzDkdCPsVDAtYM,6720
 fprime_gds/flask/channels.py,sha256=sOeL-UmWPh2hqYvqj81STpABLlPcjdPgkRwjd3Qx77k,735
-fprime_gds/flask/commands.py,sha256=pizE0AQ2Id5xAMBucdAf93ARVinnBQD8y5afAp2i5oo,3636
+fprime_gds/flask/commands.py,sha256=62R3b0mnjc3_XpULpqJyUSvAcfOjAyZNifQ3wqHKO7s,3658
 fprime_gds/flask/components.py,sha256=a-eG8XJfSrqR8MIzIc9StwbNwxcBqkxYMEYq46S2Bmk,4176
 fprime_gds/flask/default_settings.py,sha256=SkNfd5R4tv59rcmPiHERIZNIEmzXP3KJcJZektgtZCA,603
 fprime_gds/flask/errors.py,sha256=yN3jDsJd30jL6aOIF-SqbVoesvReHqPvXlIt8qWB87M,2133
@@ -154,20 +154,20 @@ fprime_gds/flask/static/addons/chart-display/vendor/chartjs-adapter-luxon.min.js
 fprime_gds/flask/static/addons/chart-display/vendor/hammer.min.js,sha256=SKSRJkZzVMqQzhFeghSWUsCtUon42GUc4gDWk914lDw,20727
 fprime_gds/flask/static/addons/commanding/addon.js,sha256=d027BtN0LTSIWh1vtL1LIdf0k33tAw1kJ9GIDPbNY4o,263
 fprime_gds/flask/static/addons/commanding/argument-templates.js,sha256=vx5FP1ZCFT2w_Rc5fIIpaXnOoEq6vhy3tjIbOddwX3w,4528
-fprime_gds/flask/static/addons/commanding/arguments.js,sha256=_pcoHumf8qJhw-qfAzZ0_AU1SNAuXSRt55LHYG9t8p4,13304
+fprime_gds/flask/static/addons/commanding/arguments.js,sha256=6UYPwa7KW5nso-pBPs9n9TsGbEq9FUDBtG3eFectThY,14274
 fprime_gds/flask/static/addons/commanding/command-history-template.js,sha256=2ak2B9eio3PLq6Bnie8iEsQN3HDJYokl0usMMP1D6lE,753
-fprime_gds/flask/static/addons/commanding/command-history.js,sha256=iVyMFP_GkqxiMAkK_U2JeTqo96Q-nTghO8eKo3NFXQ0,4816
+fprime_gds/flask/static/addons/commanding/command-history.js,sha256=rEJBsYCFtCXCQewlIUjW2ATG0vPVjQywsbZQ9u8iN0g,3995
 fprime_gds/flask/static/addons/commanding/command-input-template.js,sha256=Z3fHmPTaAnXDhHMu07bRMBse6wjJSexAStgV9pSeh8Q,2959
-fprime_gds/flask/static/addons/commanding/command-input.js,sha256=utcmiLCkzU-CsBvBZsV32_UvKPVTuIOCafHsm3o2104,8973
-fprime_gds/flask/static/addons/commanding/command-string-template.js,sha256=7Mq4BPcAS57WoyF9aAMdKLtMFN4DLbQVTAQ8YUQEITI,743
-fprime_gds/flask/static/addons/commanding/command-string.js,sha256=q3ThUW45RHDE1gnKPxz44LOJgxXD24YTrYYlvBSfXrA,2553
+fprime_gds/flask/static/addons/commanding/command-input.js,sha256=I2SZslctv7DyOmlmEhVsYRq6tPRAkWuNgikGDOmJn0o,9094
+fprime_gds/flask/static/addons/commanding/command-string-template.js,sha256=tb0NJ24XtiEWaeY6e2MpNnb2uATRi7q7d2TrZEumvqw,825
+fprime_gds/flask/static/addons/commanding/command-string.js,sha256=MAPG9Q0QyWTNxF1Urnxbz1AYC06p8mWPdThEZwpxFF8,2686
 fprime_gds/flask/static/addons/dictionary/addon-templates.js,sha256=19hYvx_Gf8B5j4po0YKeQrhS2UbUIBAEfqgbDGE2peE,950
 fprime_gds/flask/static/addons/dictionary/addon.js,sha256=eKggJNvOzj2ssXOenc7ccRUTRgeOJ5d4grWliaxgV40,1350
 fprime_gds/flask/static/addons/image-display/addon.js,sha256=Uo1JzqsqF4be9B3DAPH-LIm2MhqwUAhvTvobigpZB0Y,1522
 fprime_gds/flask/static/addons/image-display/dashboard.xml,sha256=t0g0v35YxV85MBhGSR_EkKBLRyglQ2Z7IQwfwvhuJAU,263
 fprime_gds/flask/static/addons/sequencer/README.md,sha256=-9DULIhPIZIWNSHZmenqrPA-G4OAxmclHukoaHlgIeM,1681
 fprime_gds/flask/static/addons/sequencer/addon-templates.js,sha256=jdZqBQBAKCwKsv60uWhF1Sd6A6WBeBcZ39yXAUlGpLE,3241
-fprime_gds/flask/static/addons/sequencer/addon.js,sha256=lH__umiGj836mEB4BupOBXyLPYRlKZjDq3lICfKJhCU,5116
+fprime_gds/flask/static/addons/sequencer/addon.js,sha256=FX3gkVtA7TuvvjmHNRAZ1wAfJvQ5qk4wtY0o3jYUetc,5188
 fprime_gds/flask/static/addons/sequencer/autocomplete.js,sha256=O6qT8SjN7xuK0edaCpphENN_dLD8-ceRvE6lPNsZui8,6990
 fprime_gds/flask/static/addons/sequencer/lint.js,sha256=QPt9bt0SMZxMu6cXFkqILwgLlcTmcO0WbRQE8X2XIbQ,1472
 fprime_gds/flask/static/addons/sequencer/third/code-mirror.es.js,sha256=u-m1Nh7jnodMrnO1zR7eg0k7Lhwp8nt4nUwwJiKwyuU,813045
@@ -184,7 +184,8 @@ fprime_gds/flask/static/img/success.svg,sha256=wCfYG4cPfSCcsZ76JI4SwAJ-y62rahx9r
 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/gds.js,sha256=OeDJrNmNA8hUPi8QIHP-s33MW_IYT3QIccxzL75MsjA,1297
-fprime_gds/flask/static/js/loader.js,sha256=cpvd1P6jMaoVovGPR6iOHR5K6LR8Ga0F69qb6dwZ4cI,15521
+fprime_gds/flask/static/js/json.js,sha256=KUiuQBWKsSNA5TjU57azEIAzCb5zNsge7JEiR8c3i5M,12022
+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
 fprime_gds/flask/static/js/uploader.js,sha256=HdFUGwJ-SN_OEMXiXXJw0YblC0j_QiOA1y9yVWyS4SI,2730
@@ -227,10 +228,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.5.2a1.dist-info/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fprime_gds-3.5.2a1.dist-info/METADATA,sha256=CpfCc4EoQcCptAW0sMgR25EgrSc897Y4ckCvg_K4ims,24772
-fprime_gds-3.5.2a1.dist-info/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
-fprime_gds-3.5.2a1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-fprime_gds-3.5.2a1.dist-info/entry_points.txt,sha256=oqUiO3xhJCR943jdU3zcxbqEvSXNeVgshk7dVaf_nGY,322
-fprime_gds-3.5.2a1.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
-fprime_gds-3.5.2a1.dist-info/RECORD,,
+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.5.2a1.dist-info → fprime_gds-3.6.0.dist-info}/WHEEL

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