fprime-gds 3.4.1__py3-none-any.whl → 3.4.2__py3-none-any.whl

fprime_gds/common/encoders/seq_writer.py

@@ -137,9 +137,9 @@ class SeqBinaryWriter:
         for cmd in seq_cmds_list:
             sequence += self.__binaryCmdRecord(cmd)
         size = len(sequence)
-        tb_txt = b"ANY" if self.__timebase == 0xFFFF else bytes(self.__timebase)
+        tb_txt = "ANY" if self.__timebase == 0xFFFF else hex(self.__timebase)
 
-        print("Sequence is %d bytes with timebase %s" % (size, tb_txt))
+        print(f"Sequence is {size} bytes with timebase {tb_txt}")
 
         header = b""
         header += U32Type(

fprime_gds/common/files/uplinker.py

@@ -47,7 +47,9 @@ class UplinkQueue:
         self.queue = queue.Queue()
         self.__file_store = []
         self.__exit = threading.Event()
-        self.__thread = threading.Thread(target=self.run, name="UplinkerThread", args=())
+        self.__thread = threading.Thread(
+            target=self.run, name="UplinkerThread", args=()
+        )
         self.__thread.start()
 
     def enqueue(self, filepath, destination):
@@ -228,9 +230,7 @@ class FileUplinker(fprime_gds.common.handlers.DataHandler):
         # Prevent multiple uplinks at once
         if self.state != FileStates.IDLE:
             msg = f"Currently uplinking file '{self.active.source}' cannot start uplinking '{file_obj.source}'"
-            raise FileUplinkerBusyException(
-                msg
-            )
+            raise FileUplinkerBusyException(msg)
         self.state = FileStates.RUNNING
         self.active = file_obj
         self.active.open(TransmitFileState.READ)

fprime_gds/common/loaders/xml_loader.py

@@ -61,6 +61,7 @@ class XmlLoader(dict_loader.DictLoader):
     SER_MEMB_FMT_STR_TAG = "format_specifier"
     SER_MEMB_DESC_TAG = "description"
     SER_MEMB_TYPE_TAG = "type"
+    SER_MEMB_SIZE_TAG = "size"
 
     # Xml section names and tags for array types
     ARR_SECT = "arrays"
@@ -256,7 +257,15 @@ class XmlLoader(dict_loader.DictLoader):
                     fmt_str = memb.get(self.SER_MEMB_FMT_STR_TAG)
                     desc = memb.get(self.SER_MEMB_DESC_TAG)
                     memb_type_name = memb.get(self.SER_MEMB_TYPE_TAG)
+                    memb_size = memb.get(self.SER_MEMB_SIZE_TAG)
                     type_obj = self.parse_type(memb_type_name, memb, xml_obj)
+                    # memb_size is not None for member array
+                    if(memb_size is not None):
+                        type_obj = ArrayType.construct_type(
+                            f"Array_{type_obj.__name__}_{memb_size}",
+                            type_obj,
+                            int(memb_size),
+                            fmt_str)
 
                     members.append((name, type_obj, fmt_str, desc))
 

fprime_gds/common/pipeline/files.py

@@ -7,7 +7,7 @@ communications layer.
 
 @author mstarch
 """
-import os
+from pathlib import Path
 import fprime_gds.common.files.downlinker
 import fprime_gds.common.files.uplinker
 
@@ -43,10 +43,11 @@ class Filing:
         )
         file_decoder.register(self.__downlinker)
         distributor.register("FW_PACKET_HAND", self.__uplinker)
-        if not os.access(down_store, os.W_OK):
+        try:
+            Path(down_store).mkdir(parents=True, exist_ok=True)
+        except PermissionError:
             raise PermissionError(
-                f"{down_store} is not writable. Downlinker not be able to save files. "
-                "Fix permissions or change storage directory with --file-storage-directory."
+                f"{down_store} is not writable. Fix permissions or change storage directory with --file-storage-directory."
             )
 
     @property

fprime_gds/common/pipeline/standard.py

@@ -44,6 +44,8 @@ class StandardPipeline:
         self.client_socket = None
         self.logger = None
         self.dictionary_path = None
+        self.up_store = None
+        self.down_store = None
 
         self.__dictionaries = dictionaries.Dictionaries()
         self.__coders = encoding.EncodingDecoding()
@@ -52,7 +54,7 @@ class StandardPipeline:
         self.__transport_type = ThreadedTCPSocketClient
 
     def setup(
-        self, config, dictionary, down_store, logging_prefix=None, packet_spec=None
+        self, config, dictionary, file_store, logging_prefix=None, packet_spec=None
     ):
         """
         Setup the standard pipeline for moving data from the middleware layer through the GDS layers using the standard
@@ -60,11 +62,23 @@ class StandardPipeline:
 
         :param config: config object used when constructing the pipeline.
         :param dictionary: dictionary path. Used to setup loading of dictionaries.
-        :param down_store: downlink storage directory
+        :param file_store: uplink/downlink storage directory
         :param logging_prefix: logging prefix. Defaults to not logging at all.
         :param packet_spec: location of packetized telemetry XML specification.
         """
-        assert dictionary is not None and Path(dictionary).is_file(), f"Dictionary {dictionary} does not exist"
+        assert (
+            dictionary is not None and Path(dictionary).is_file()
+        ), f"Dictionary {dictionary} does not exist"
+        # File storage configuration for uplink and downlink
+        self.up_store = Path(file_store) / "fprime-uplink"
+        self.down_store = Path(file_store) / "fprime-downlink"
+        try:
+            self.down_store.mkdir(parents=True, exist_ok=True)
+            self.up_store.mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            raise PermissionError(
+                f"{file_store} is not writable. Fix permissions or change storage directory with --file-storage-directory."
+            )
         self.dictionary_path = Path(dictionary)
         # Loads the distributor and client socket
         self.distributor = fprime_gds.common.distributor.distributor.Distributor(config)
@@ -76,7 +90,7 @@ class StandardPipeline:
         )
         self.histories.setup_histories(self.coders)
         self.files.setup_file_handling(
-            down_store,
+            self.down_store,
             self.coders.file_encoder,
             self.coders.file_decoder,
             self.distributor,
@@ -152,7 +166,11 @@ class StandardPipeline:
             outgoing_tag: this pipeline will produce data for supplied tag (FSW, GUI). Default: FSW
         """
         # Backwards compatibility with the old method .connect(host, port)
-        if isinstance(incoming_tag, int) and ":" not in connection_uri and outgoing_tag == RoutingTag.FSW:
+        if (
+            isinstance(incoming_tag, int)
+            and ":" not in connection_uri
+            and outgoing_tag == RoutingTag.FSW
+        ):
             connection_uri = f"{connection_uri}:{incoming_tag}"
             incoming_tag = RoutingTag.GUI
         self.client_socket.connect(connection_uri, incoming_tag, outgoing_tag)

fprime_gds/common/testing_fw/api.py

@@ -402,7 +402,7 @@ class IntegrationTestAPI(DataHandler):
             return self.await_event_sequence(events, start=start, timeout=timeout)
         return self.await_event(events, start=start, timeout=timeout)
 
-    def send_and_assert_command(self, command, args=[], max_delay=None, timeout=5, events=None):
+    def send_and_assert_command(self, command, args=[], max_delay=None, timeout=5, events=None, commander="cmdDisp"):
         """
         This helper will send a command and verify that the command was dispatched and completed
         within the F' deployment. This helper can retroactively check that the delay between
@@ -414,12 +414,13 @@ class IntegrationTestAPI(DataHandler):
             max_delay: the maximum allowable delay between dispatch and completion (int/float)
             timeout: the number of seconds to wait before terminating the search (int)
             events: extra event predicates to check between  dispatch and complete
+            commander: the command dispatching component. Defaults to cmdDisp
         Return:
             returns a list of the EventData objects found by the search
         """
         cmd_id = self.translate_command_name(command)
-        dispatch = [self.get_event_pred("cmdDisp.OpCodeDispatched", [cmd_id, None])]
-        complete = [self.get_event_pred("cmdDisp.OpCodeCompleted", [cmd_id])]
+        dispatch = [self.get_event_pred(f"{commander}.OpCodeDispatched", [cmd_id, None])]
+        complete = [self.get_event_pred(f"{commander}.OpCodeCompleted", [cmd_id])]
         events = dispatch + (events if events else []) + complete
         results = self.send_and_assert_event(command, args, events, timeout=timeout)
         if max_delay is not None:

fprime_gds/executables/cli.py

@@ -547,18 +547,31 @@ class FileHandlingParser(ParserBase):
 
         return {
             ("--file-storage-directory",): {
-                "dest": "files_directory",
+                "dest": "files_storage_directory",
                 "action": "store",
-                "default": "/tmp/" + username + "/fprime-downlink/",
+                "default": "/tmp/" + username,
                 "required": False,
                 "type": str,
-                "help": "File to store uplink and downlink files. Default: %(default)s",
-            }
+                "help": "Directory to store uplink and downlink files. Default: %(default)s",
+            },
+            ("--remote-sequence-directory",): {
+                "dest": "remote_sequence_directory",
+                "action": "store",
+                "default": "/seq",
+                "required": False,
+                "type": str,
+                "help": "Directory to save command sequence binaries, on the remote FSW. Default: %(default)s",
+            },
         }
 
     def handle_arguments(self, args, **kwargs):
         """Handle arguments as parsed"""
-        os.makedirs(args.files_directory, exist_ok=True)
+        try:
+            Path(args.files_storage_directory).mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            raise PermissionError(
+                f"{args.files_storage_directory} is not writable. Fix permissions or change storage directory with --file-storage-directory."
+            )
         return args
 
 
@@ -584,7 +597,7 @@ class StandardPipelineParser(CompositeParser):
         pipeline_arguments = {
             "config": ConfigManager(),
             "dictionary": args_ns.dictionary,
-            "down_store": args_ns.files_directory,
+            "file_store": args_ns.files_storage_directory,
             "packet_spec": args_ns.packet_spec,
             "logging_prefix": args_ns.logs,
         }

fprime_gds/executables/comm.py

@@ -64,7 +64,7 @@ def main():
     )
     fprime_gds.common.communication.checksum = args.checksum_type
     if args.comm_adapter == "none":
-        print("[ERROR] Comm adapter set to 'none'. Nothing to do but exit.")
+        print("[ERROR] Comm adapter set to 'none'. Nothing to do but exit.", file=sys.stderr)
         sys.exit(-1)
 
     # Create the handling components for either side of this script, adapter for hardware, and ground for the GDS side

fprime_gds/executables/run_deployment.py

@@ -168,7 +168,7 @@ def main():
         if parsed_args.adapter == "ip":
             launchers.append(launch_app)
         else:
-            print("[WARNING] App cannot be auto-launched without IP adapter")
+            print("[WARNING] App cannot be auto-launched without IP adapter", file=sys.stderr)
 
     # Launch the desired GUI package
     if parsed_args.gui == "html":

fprime_gds/executables/utils.py

@@ -146,11 +146,12 @@ def get_artifacts_root() -> Path:
         ini_settings = IniSettings.load(ini_file)
     except FprimeLocationUnknownException:
         print(
-            "[ERROR] Not in fprime project and no deployment path provided, unable to find dictionary and/or app"
+            "[ERROR] Not in fprime project and no deployment path provided, unable to find dictionary and/or app",
+            file=sys.stderr
         )
         sys.exit(-1)
     except FprimeSettingsException as e:
-        print("[ERROR]", e)
+        print("[ERROR]", e, file=sys.stderr)
         sys.exit(-1)
     assert (
         "install_destination" in ini_settings
@@ -165,17 +166,18 @@ def find_app(root: Path) -> Path:
     bin_dir = root / "bin"
 
     if not bin_dir.exists():
-        print(f"[ERROR] binary location {bin_dir} does not exist")
+        print(f"[ERROR] binary location {bin_dir} does not exist", file=sys.stderr)
         sys.exit(-1)
 
     files = [child for child in bin_dir.iterdir() if child.is_file()]
     if not files:
-        print(f"[ERROR] App not found in {bin_dir}")
+        print(f"[ERROR] App not found in {bin_dir}", file=sys.stderr)
         sys.exit(-1)
 
     if len(files) > 1:
         print(
-            f"[ERROR] Multiple app candidates in binary location {bin_dir}. Specify app manually with --app."
+            f"[ERROR] Multiple app candidates in binary location {bin_dir}. Specify app manually with --app.",
+            file=sys.stderr
         )
         sys.exit(-1)
 
@@ -186,7 +188,7 @@ def find_dict(root: Path) -> Path:
     dict_dir = root / "dict"
 
     if not dict_dir.exists():
-        print(f"[ERROR] dictionary location {dict_dir} does not exist")
+        print(f"[ERROR] dictionary location {dict_dir} does not exist", file=sys.stderr)
         sys.exit(-1)
 
     files = [
@@ -196,12 +198,13 @@ def find_dict(root: Path) -> Path:
     ]
 
     if not files:
-        print(f"[ERROR] No xml dictionary found in dictionary location {dict_dir}")
+        print(f"[ERROR] No xml dictionary found in dictionary location {dict_dir}", file=sys.stderr)
         sys.exit(-1)
 
     if len(files) > 1:
         print(
-            f"[ERROR] Multiple xml dictionaries found in dictionary location {dict_dir}. Specify dictionary manually with --dictionary."
+            f"[ERROR] Multiple xml dictionaries found in dictionary location {dict_dir}. Specify dictionary manually with --dictionary.",
+            file=sys.stderr
         )
         sys.exit(-1)
 

fprime_gds/flask/app.py

@@ -30,7 +30,6 @@ import fprime_gds.flask.sequence
 import fprime_gds.flask.stats
 import fprime_gds.flask.updown
 from fprime_gds.executables.cli import ParserBase, StandardPipelineParser
-from fprime_gds.flask import flask_uploads
 
 from . import components
 
@@ -49,8 +48,7 @@ def construct_app():
     2. Setup JSON encoding for Flask and flask_restful to handle F prime types natively
     3. Setup standard pipeline used throughout the system
     4. Create Restful API for registering flask items
-    5. Setup flask_uploads settings
-    6. Register all restful endpoints
+    5. Register all restful endpoints
 
     :return: setup app
     """
@@ -77,9 +75,6 @@ def construct_app():
 
     # Restful API registration
     api = fprime_gds.flask.errors.setup_error_handling(app)
-    # File upload configuration, 1 set for everything
-    uplink_set = flask_uploads.UploadSet("uplink", flask_uploads.ALL)
-    flask_uploads.configure_uploads(app, [uplink_set])
 
     # Application routes
     api.add_resource(
@@ -137,7 +132,7 @@ def construct_app():
     api.add_resource(
         fprime_gds.flask.updown.FileUploads,
         "/upload/files",
-        resource_class_args=[pipeline.files.uplinker, uplink_set],
+        resource_class_args=[pipeline.files.uplinker, pipeline.up_store],
     )
     api.add_resource(
         fprime_gds.flask.updown.FileDownload,
@@ -150,9 +145,9 @@ def construct_app():
         "/sequence",
         resource_class_args=[
             args_ns.dictionary,
-            app.config["UPLOADED_UPLINK_DEST"],
+            pipeline.up_store,
             pipeline.files.uplinker,
-            app.config["REMOTE_SEQ_DIRECTORY"],
+            args_ns.remote_sequence_directory,
         ],
     )
     api.add_resource(

fprime_gds/flask/default_settings.py

@@ -9,23 +9,12 @@
 #
 ####
 import os
-import getpass
-
-# Select uploads directory and create it
-username = getpass.getuser()
-uplink_dir = os.environ.get("UP_FILES_DIR", "/tmp/" + username + "/fprime-uplink/")
-DOWNLINK_DIR = os.environ.get("DOWN_FILES_DIR", "/tmp/" + username + "/fprime-downlink/")
 
 STANDARD_PIPELINE_ARGUMENTS = os.environ.get("STANDARD_PIPELINE_ARGUMENTS").split("|")
 
 SERVE_LOGS = os.environ.get("SERVE_LOGS", "YES") == "YES"
-UPLOADED_UPLINK_DEST = uplink_dir
-UPLOADS_DEFAULT_DEST = uplink_dir
-REMOTE_SEQ_DIRECTORY = "/seq"
-MAX_CONTENT_LENGTH = 32 * 1024 * 1024  # Max length of request is 32MiB
 
+MAX_CONTENT_LENGTH = 32 * 1024 * 1024  # Max length of request is 32MiB
 
-for directory in [UPLOADED_UPLINK_DEST, UPLOADS_DEFAULT_DEST, DOWNLINK_DIR]:
-    os.makedirs(directory, exist_ok=True)
 
 # TODO: load real config

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

@@ -102,8 +102,29 @@ Vue.component("command-history", {
             cmd.full_name = template.full_name;
             // Can only set command if it is a child of a command input
             if (this.$parent.selectCmd) {
-                this.$parent.selectCmd(cmd.full_name, cmd.args);
+                // 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;
             }
         }
     }
-});
+});

fprime_gds/flask/updown.py

@@ -11,6 +11,9 @@ import os
 
 import flask
 import flask_restful
+from werkzeug.datastructures import FileStorage
+from werkzeug.utils import secure_filename
+from pathlib import Path
 
 
 class Destination(flask_restful.Resource):
@@ -51,12 +54,12 @@ class FileUploads(flask_restful.Resource):
     A data model for the current uplinking file set.
     """
 
-    def __init__(self, uplinker, uplink_set):
+    def __init__(self, uplinker, dest_dir):
         """
         Constructor: setup the uplinker and argument parsing
         """
         self.uplinker = uplinker
-        self.uplink_set = uplink_set
+        self.dest_dir = dest_dir
         self.parser = flask_restful.reqparse.RequestParser()
         self.parser.add_argument(
             "action", required=True, help="Action to take against files"
@@ -99,11 +102,9 @@ class FileUploads(flask_restful.Resource):
         failed = []
         for key, file in flask.request.files.items():
             try:
-                filename = self.uplink_set.save(file)
+                filename = self.save(file)
                 flask.current_app.logger.info(f"Received file. Saved to: {filename}")
-                self.uplinker.enqueue(
-                    os.path.join(self.uplink_set.config.destination, filename)
-                )
+                self.uplinker.enqueue(os.path.join(self.dest_dir, filename))
                 successful.append(key)
             except Exception as exc:
                 flask.current_app.logger.warning(
@@ -112,6 +113,56 @@ class FileUploads(flask_restful.Resource):
                 failed.append(key)
         return {"successful": successful, "failed": failed}
 
+    def save(self, file_storage: FileStorage):
+        """
+        This saves a `werkzeug.FileStorage` into this upload set.
+
+        :param file_storage: The uploaded file to save.
+        """
+        if not isinstance(file_storage, FileStorage):
+            raise TypeError("file_storage must be a werkzeug.FileStorage")
+
+        filename = Path(secure_filename(file_storage.filename)).name
+        dest_dir = Path(self.dest_dir)
+
+        try:
+            dest_dir.mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            raise PermissionError(
+                f"{dest_dir} is not writable. Fix permissions or change storage directory with --file-storage-directory."
+            )
+
+        # resolve conflict may not be needed
+        if (dest_dir / filename).exists():
+            filename = self.resolve_conflict(dest_dir, filename)
+
+        target = dest_dir / filename
+        file_storage.save(str(target))
+
+        return filename
+
+    def resolve_conflict(self, target_folder: Path, filename: str):
+        """
+        If a file with the selected name already exists in the target folder,
+        this method is called to resolve the conflict. It should return a new
+        filename for the file.
+
+        The default implementation splits the name and extension and adds a
+        suffix to the name consisting of an underscore and a number, and tries
+        that until it finds one that doesn't exist.
+
+        :param target_folder: The absolute path to the target.
+        :param filename: The file's original filename.
+        """
+        path = Path(filename)
+        name, ext = path.stem, path.suffix
+        count = 0
+        while True:
+            count = count + 1
+            newname = f"{name}_{count}{ext}"
+            if not (Path(target_folder) / newname).exists():
+                return newname
+
 
 class FileDownload(flask_restful.Resource):
     """ """

{fprime_gds-3.4.1.dist-info → fprime_gds-3.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fprime-gds
-Version: 3.4.1
+Version: 3.4.2
 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.4.1.dist-info → fprime_gds-3.4.2.dist-info}/RECORD

@@ -38,12 +38,12 @@ fprime_gds/common/encoders/encoder.py,sha256=xgFFCi-qKEKG7T5Qfo-qIadSiY0NSnfDgQU
 fprime_gds/common/encoders/event_encoder.py,sha256=Thpa6aNHK_Q_mO_u3PlGohbR1oiqxCyPsWKdHq6GQVs,3121
 fprime_gds/common/encoders/file_encoder.py,sha256=G9uUXQP-oD2eW_GJuGNBrN7xPafKFhmgKiNi-zvZz-g,3830
 fprime_gds/common/encoders/pkt_encoder.py,sha256=JthlbMIumPcaGDoDx7h9vI4rDb8Hvenr9pffTL7XCtU,3098
-fprime_gds/common/encoders/seq_writer.py,sha256=s-53D2GBwERVnIiN9QrdLnQTwwVpf2ul5mVhdXcIdPs,6872
+fprime_gds/common/encoders/seq_writer.py,sha256=Zmj482qe_IQVx3EDmfXlPKKTJcEyDMRCWk28yc4C4-8,6863
 fprime_gds/common/files/File Decoder Documentation.txt,sha256=a-VYHcUMqh7mBGY2fqvMf1nd3gdg3cLdPKwrulNKXjc,5314
 fprime_gds/common/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/files/downlinker.py,sha256=CZPfhH0J9-LNqW5Cv_ryicLTuoedLSWK8OPQmmQDZZY,7498
 fprime_gds/common/files/helpers.py,sha256=sGaxcczXmZ5_soawT7x_eJ_cC2PZ6KOGBfusAV4QC_g,7219
-fprime_gds/common/files/uplinker.py,sha256=-ZIRcGyt6e8V-NO15cGcEAf7t4eFDWZeGzFHCBGQugM,13252
+fprime_gds/common/files/uplinker.py,sha256=lgqhlgeipBt3Arx-ohzK8vCdS54fKpv9Rg7SUTocUX8,13244
 fprime_gds/common/gds_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/gds_cli/base_commands.py,sha256=RTR183kLmWPO-WXdsvPi9x1Zt7y4OJjpCJpy89Uom_Y,9410
 fprime_gds/common/gds_cli/channels.py,sha256=S8y0Mo2JbBFPvMzeW22HFVJ8p-UC-tzpYM7rXqIGWi4,2136
@@ -66,7 +66,7 @@ fprime_gds/common/loaders/event_py_loader.py,sha256=m4KlDl0mXn8ZQr-IfpUg0KaGIOJU
 fprime_gds/common/loaders/event_xml_loader.py,sha256=DXyriGpGiuzG1a5Eyb8PLH3x7X1-hNxiIpY_yC3UPgQ,2790
 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=6OqYz3jyHwoKZ76FKkbkqbxoqFMcc55tK2itXU-5iUk,13460
+fprime_gds/common/loaders/xml_loader.py,sha256=inrVbfhPOHzziGdZgdR1wgspdXYXvh-I9zgf_knPZeo,13914
 fprime_gds/common/logger/__init__.py,sha256=YBrr9An0fZbp4kvphRl8nLfolkdBqFAsSGzEZXQiH6g,1448
 fprime_gds/common/logger/data_logger.py,sha256=VjfhTGO1gGw954xNhSc0_zpw8JexCho5f8BlXDEYkL4,2505
 fprime_gds/common/logger/test_logger.py,sha256=wL8Lq49sVmxGRALgv-ei6AnXFh79qlHFehmKJ1A8X28,6475
@@ -80,10 +80,10 @@ fprime_gds/common/parsers/seq_file_parser.py,sha256=6DZrA0jmt8IqsutfK7pdLtYn4oVH
 fprime_gds/common/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/pipeline/dictionaries.py,sha256=yWt-Q4bFGbP7yQoZGZzqLFVDnCY371TQFxZj4hSYGH0,5576
 fprime_gds/common/pipeline/encoding.py,sha256=rMCBoZOrnLctl4QNlbMro_QiCQ4sapWjtcoFGfvO-WM,6631
-fprime_gds/common/pipeline/files.py,sha256=GBI8oxfdfFXmw7G9jGeK7H4x2vqZWeaXj5iDHyJtoJo,2224
+fprime_gds/common/pipeline/files.py,sha256=J2zm0sucvImtmSnv0iUp5uTpvUO8nlmz2lUdMuMC5aM,2244
 fprime_gds/common/pipeline/histories.py,sha256=P1TN6mFOe9f5cZ_a-vCDN9o94vM7ax9n6fQogfUCce0,3548
 fprime_gds/common/pipeline/router.py,sha256=-P1wI0KXEh_snOzDaq8CjEoWuM_zRm8vUMR1T0oY9qQ,2327
-fprime_gds/common/pipeline/standard.py,sha256=UxAM1joLMXQLJEpaQVfJnkGnoimlUOKuiiqlKJ70UOg,8656
+fprime_gds/common/pipeline/standard.py,sha256=k0QyPkRxjTMGFC-6O25LDxBQnAa5ibe1hj9cjjEPzOU,9325
 fprime_gds/common/templates/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fprime_gds/common/templates/ch_template.py,sha256=1MoDZsia0dI_CvnIttwyKLhbQhum35OcJnFc50Xohuo,3893
 fprime_gds/common/templates/cmd_template.py,sha256=Bdkfgjb9Yqw7zaZyS8fR9ZUebrkFsRofF0g7xpKtkE4,5180
@@ -91,7 +91,7 @@ fprime_gds/common/templates/data_template.py,sha256=U87d8oC-BDTDuBRZbNnPkXy6rI_P
 fprime_gds/common/templates/event_template.py,sha256=L0hkWB_kEMhTNodPUqBAev76SMmWT9EWdcqxaaQX9ZE,4062
 fprime_gds/common/templates/pkt_template.py,sha256=5Wi6389m5j8w7JITBGfeUnw6CYE1-hjcVJ42NJmLDcE,1794
 fprime_gds/common/testing_fw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/common/testing_fw/api.py,sha256=vlwkXHnU1-3bkYgWLr5bpR9poLRt5hHCdmNBHGstQvg,60457
+fprime_gds/common/testing_fw/api.py,sha256=6rdgh6M0NkRVy69EeDh4z343Bjxp2CtBLj0b83U2ka8,60566
 fprime_gds/common/testing_fw/predicates.py,sha256=CsHsVs_EVXCLQLd2NVOvy8MxmUQVxLMr3i1ouEUqOtQ,18371
 fprime_gds/common/testing_fw/pytest_integration.py,sha256=FjbbsfLyScb9w4zypcQgahmNMgmh4yXwryfy9h2eaBY,4667
 fprime_gds/common/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -102,28 +102,27 @@ fprime_gds/common/utils/data_desc_type.py,sha256=9GV8hV5q1dDxdfF-1-Wty5MBrFd94Eb
 fprime_gds/common/utils/event_severity.py,sha256=7qPXHrDaM_REJ7sKBUEJTZIE0D4qVnVajsPDUuHg7sI,300
 fprime_gds/common/utils/string_util.py,sha256=jqut5Dd0EjvTHMci1mvs_8KQ1Nq-38xZofeaaSoiJEY,3985
 fprime_gds/executables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/executables/cli.py,sha256=aowCrVbQRLqDXe5bs4dngFNsgN2Dnk22x4EHyOzozMI,30504
-fprime_gds/executables/comm.py,sha256=ldh6DT6W9Aq-0mmsrlBkS7SasgULZTmB8PXJg6ffvSM,5365
+fprime_gds/executables/cli.py,sha256=F4qkckoYCoGlh5T_WByOj6CDI3wm_nBM1K57wzkXmtM,31127
+fprime_gds/executables/comm.py,sha256=86CO8eczu5y2lsdPnPPFtK1pEUVLrSyU9smC09bON-Q,5382
 fprime_gds/executables/fprime_cli.py,sha256=GvvuUQuoDGBrqQB867bDjUR3Kn5yPUckAY2rdfTa8jo,12432
-fprime_gds/executables/run_deployment.py,sha256=JOjugASDEK2nzPIAgOh3sr-dEqlcRJOiA5gf_QrEQjA,6140
+fprime_gds/executables/run_deployment.py,sha256=4M5646tH-LdjEgQGwAIJ3mf10pfivHlDBPrUwhLkJWI,6157
 fprime_gds/executables/tcpserver.py,sha256=KspVpu5YIuiWKOk5E6UDMKvqXYrRB1j9aX8CkMxysfw,17555
-fprime_gds/executables/utils.py,sha256=WgQbD_sBcTVj331Loii59T3Qli7ZSOJkkU-AK6iz2Jc,7023
+fprime_gds/executables/utils.py,sha256=CTw2gMO3vguqra8V8AEJodY6zcX18zO4AyA-EKwThmM,7195
 fprime_gds/flask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fprime_gds/flask/app.py,sha256=C3J4WcmURYKJWzuZv7G6GiSxXOJVzXw5GYSDkUILGcI,6989
+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/components.py,sha256=a-eG8XJfSrqR8MIzIc9StwbNwxcBqkxYMEYq46S2Bmk,4176
-fprime_gds/flask/default_settings.py,sha256=ifR7shud5maJzlxu_YDHZYbm9i3IjhujnyMSrnY-tqw,1080
+fprime_gds/flask/default_settings.py,sha256=SkNfd5R4tv59rcmPiHERIZNIEmzXP3KJcJZektgtZCA,603
 fprime_gds/flask/errors.py,sha256=yN3jDsJd30jL6aOIF-SqbVoesvReHqPvXlIt8qWB87M,2133
 fprime_gds/flask/events.py,sha256=BO9OUUwNDnRuOz4ZC6nFHMR7sJJ9P2P0xUxDluGd218,732
-fprime_gds/flask/flask_uploads.py,sha256=DW3v3U7Rw7k7PLlcG9Yc9RCtM4tpvKUm8OWEM6ZQQZ0,19778
 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/sequence.py,sha256=P4yhxiM4dQxwCcAo9dT4J6bogxkBhWapqLxeaHurBBA,3553
 fprime_gds/flask/stats.py,sha256=i62envu9V6WpNsRD_mlhwzB_2dGUOCTf1XpyC5HApzg,1177
-fprime_gds/flask/updown.py,sha256=8Al-kZ1BXA6JFeZYLhDYFoUh1j5DR0Dt0EpJrN50pu8,4289
+fprime_gds/flask/updown.py,sha256=7za_zgOwQKHgm-3W1OBZqBgDLCmj7c0ziFEduhEuqdU,6176
 fprime_gds/flask/static/favicon.ico,sha256=pwqBRx64V_wyrrXgXsBXPWWUmwqanuWAfesMpFfV1E4,15406
 fprime_gds/flask/static/index.html,sha256=7SPp-p3ywyBtElPWEAAjrBuh-PNr8LUtd1JXw6emcVU,26087
 fprime_gds/flask/static/.idea/.gitignore,sha256=NHNmSnP0xfbzJRKbluJMetE8N_J3-dXL-arvLWCrYTk,38
@@ -151,7 +150,7 @@ fprime_gds/flask/static/addons/commanding/addon.js,sha256=d027BtN0LTSIWh1vtL1LId
 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/command-history-template.js,sha256=2ak2B9eio3PLq6Bnie8iEsQN3HDJYokl0usMMP1D6lE,753
-fprime_gds/flask/static/addons/commanding/command-history.js,sha256=4p7z60Ub0eJ6edRN9zM0ODNxONkpHQQ8Iw3mbQ4MUmk,3849
+fprime_gds/flask/static/addons/commanding/command-history.js,sha256=iVyMFP_GkqxiMAkK_U2JeTqo96Q-nTghO8eKo3NFXQ0,4816
 fprime_gds/flask/static/addons/commanding/command-input-template.js,sha256=Z3fHmPTaAnXDhHMu07bRMBse6wjJSexAStgV9pSeh8Q,2959
 fprime_gds/flask/static/addons/commanding/command-input.js,sha256=l2sSqZbhLjrLdMGDdm1YPNTR1JCpXhR79A8exfcwHco,8842
 fprime_gds/flask/static/addons/commanding/command-string-template.js,sha256=7Mq4BPcAS57WoyF9aAMdKLtMFN4DLbQVTAQ8YUQEITI,743
@@ -219,10 +218,10 @@ fprime_gds/flask/static/third-party/webfonts/fa-solid-900.svg,sha256=lnTrG9VQRxe
 fprime_gds/flask/static/third-party/webfonts/fa-solid-900.ttf,sha256=r2OXUD_O-9YTl2whrVweNymMGLvgfQltsDzNOvbgW6g,202744
 fprime_gds/flask/static/third-party/webfonts/fa-solid-900.woff,sha256=P200iM9lN09vZ2wxU0CwrCvoMr1VJAyAlEjjbvm5YyY,101648
 fprime_gds/flask/static/third-party/webfonts/fa-solid-900.woff2,sha256=mDS4KtJuKjdYPSJnahLdLrD-fIA1aiEU0NsaqLOJlTc,78268
-fprime_gds-3.4.1.dist-info/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fprime_gds-3.4.1.dist-info/METADATA,sha256=-bMix8wrKDI6oRJEguON4w9O-UbusSycYQ4KpcoR_k0,24755
-fprime_gds-3.4.1.dist-info/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
-fprime_gds-3.4.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-fprime_gds-3.4.1.dist-info/entry_points.txt,sha256=UisSXL905z4YEjwd7c-I2o6ZKmOw1xDDdO1mN0VPu6c,271
-fprime_gds-3.4.1.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
-fprime_gds-3.4.1.dist-info/RECORD,,
+fprime_gds-3.4.2.dist-info/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+fprime_gds-3.4.2.dist-info/METADATA,sha256=WUBi5_aQB8mc7eqrif1-T3rFL6pYeQLv6K5VC_BcE58,24755
+fprime_gds-3.4.2.dist-info/NOTICE.txt,sha256=vXjA_xRcQhd83Vfk5D_vXg5kOjnnXvLuMi5vFKDEVmg,1612
+fprime_gds-3.4.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+fprime_gds-3.4.2.dist-info/entry_points.txt,sha256=UisSXL905z4YEjwd7c-I2o6ZKmOw1xDDdO1mN0VPu6c,271
+fprime_gds-3.4.2.dist-info/top_level.txt,sha256=6vzFLIX6ANfavKaXFHDMSLFtS94a6FaAsIWhjgYuSNE,27
+fprime_gds-3.4.2.dist-info/RECORD,,

fprime_gds/flask/flask_uploads.py

@@ -1,542 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-flaskext.uploads
-================
-This module provides upload support for Flask. The basic pattern is to set up
-an `UploadSet` object and upload your files to it.
-
-:copyright: 2010 Matthew "LeafStorm" Frazier
-:license:   MIT/X11, see LICENSE for details
-
-Note: originally from https://github.com/maxcountryman/flask-uploads
-"""
-
-import sys
-
-PY3 = sys.version_info[0] == 3
-
-if PY3:
-    string_types = (str,)
-else:
-    string_types = (basestring,)
-
-import os.path
-import posixpath
-from itertools import chain  # lgtm [py/unused-import]
-
-from flask import Blueprint, abort, current_app, send_from_directory, url_for
-from werkzeug.datastructures import FileStorage
-from werkzeug.utils import secure_filename
-
-# Extension presets
-
-#: This just contains plain text files (.txt).
-TEXT = ("txt",)
-
-#: This contains various office document formats (.rtf, .odf, .ods, .gnumeric,
-#: .abw, .doc, .docx, .xls, .xlsx and .pdf). Note that the macro-enabled versions
-#: of Microsoft Office 2007 files are not included.
-DOCUMENTS = tuple("rtf odf ods gnumeric abw doc docx xls xlsx pdf".split())
-
-#: This contains basic image types that are viewable from most browsers (.jpg,
-#: .jpe, .jpeg, .png, .gif, .svg, .bmp and .webp).
-IMAGES = tuple("jpg jpe jpeg png gif svg bmp webp".split())
-
-#: This contains audio file types (.wav, .mp3, .aac, .ogg, .oga, and .flac).
-AUDIO = tuple("wav mp3 aac ogg oga flac".split())
-
-#: This is for structured data files (.csv, .ini, .json, .plist, .xml, .yaml,
-#: and .yml).
-DATA = tuple("csv ini json plist xml yaml yml".split())
-
-#: This contains various types of scripts (.js, .php, .pl, .py .rb, and .sh).
-#: If your Web server has PHP installed and set to auto-run, you might want to
-#: add ``php`` to the DENY setting.
-SCRIPTS = tuple("js php pl py rb sh".split())
-
-#: This contains archive and compression formats (.gz, .bz2, .zip, .tar,
-#: .tgz, .txz, and .7z).
-ARCHIVES = tuple("gz bz2 zip tar tgz txz 7z".split())
-
-#: This contains nonexecutable source files - those which need to be
-#: compiled or assembled to binaries to be used. They are generally safe to
-#: accept, as without an existing RCE vulnerability, they cannot be compiled,
-#: assembled, linked, or executed. Supports C, C++, Ada, Rust, Go (Golang),
-#: FORTRAN, D, Java, C Sharp, F Sharp (compiled only), COBOL, Haskell, and
-#: assembly.
-SOURCE = tuple(
-    (
-        "c cpp c++ h hpp h++ cxx hxx hdl "  # C/C++
-        + "ada "  # Ada
-        + "rs "  # Rust
-        + "go "  # Go
-        + "f for f90 f95 f03 "  # FORTRAN
-        + "d dd di "  # D
-        + "java "  # Java
-        + "hs "  # Haskell
-        + "cs "  # C Sharp
-        + "fs "  # F Sharp compiled source (NOT .fsx, which is interactive-ready)
-        + "cbl cob "  # COBOL
-        + "asm s "  # Assembly
-    ).split()
-)
-
-#: This contains shared libraries and executable files (.so, .exe and .dll).
-#: Most of the time, you will not want to allow this - it's better suited for
-#: use with `AllExcept`.
-EXECUTABLES = tuple("so exe dll".split())
-
-#: The default allowed extensions - `TEXT`, `DOCUMENTS`, `DATA`, and `IMAGES`.
-DEFAULTS = TEXT + DOCUMENTS + IMAGES + DATA
-
-
-class UploadNotAllowed(Exception):
-    """
-    This exception is raised if the upload was not allowed. You should catch
-    it in your view code and display an appropriate message to the user.
-    """
-
-
-def tuple_from(*iters):
-    return tuple(itertools.chain(*iters))
-
-
-def extension(filename):
-    ext = os.path.splitext(filename)[1]
-    if ext == "":
-        # add non-ascii filename support
-        ext = os.path.splitext(filename)[0]
-    if ext.startswith("."):
-        # os.path.splitext retains . separator
-        ext = ext[1:]
-    return ext
-
-
-def lowercase_ext(filename):
-    """
-    This is a helper used by UploadSet.save to provide lowercase extensions for
-    all processed files, to compare with configured extensions in the same
-    case.
-
-    .. versionchanged:: 0.1.4
-       Filenames without extensions are no longer lowercased, only the
-       extension is returned in lowercase, if an extension exists.
-
-    :param filename: The filename to ensure has a lowercase extension.
-    """
-    if "." in filename:
-        main, ext = os.path.splitext(filename)
-        return main + ext.lower()
-    # For consistency with os.path.splitext,
-    # do not treat a filename without an extension as an extension.
-    # That is, do not return filename.lower().
-    return filename
-
-
-def addslash(url):
-    return url if url.endswith("/") else f"{url}/"
-
-
-def patch_request_class(app, size=64 * 1024 * 1024):
-    """
-    By default, Flask will accept uploads to an arbitrary size. While Werkzeug
-    switches uploads from memory to a temporary file when they hit 500 KiB,
-    it's still possible for someone to overload your disk space with a
-    gigantic file.
-
-    This patches the app's request class's
-    `~werkzeug.BaseRequest.max_content_length` attribute so that any upload
-    larger than the given size is rejected with an HTTP error.
-
-    .. note::
-
-       In Flask 0.6, you can do this by setting the `MAX_CONTENT_LENGTH`
-       setting, without patching the request class. To emulate this behavior,
-       you can pass `None` as the size (you must pass it explicitly). That is
-       the best way to call this function, as it won't break the Flask 0.6
-       functionality if it exists.
-
-    .. versionchanged:: 0.1.1
-
-    :param app: The app to patch the request class of.
-    :param size: The maximum size to accept, in bytes. The default is 64 MiB.
-                 If it is `None`, the app's `MAX_CONTENT_LENGTH` configuration
-                 setting will be used to patch.
-    """
-    if size is None:
-        if isinstance(app.request_class.__dict__["max_content_length"], property):
-            return
-        size = app.config.get("MAX_CONTENT_LENGTH")
-    reqclass = app.request_class
-    patched = type(reqclass.__name__, (reqclass,), {"max_content_length": size})
-    app.request_class = patched
-
-
-def config_for_set(uset, app, defaults=None):
-    """
-    This is a helper function for `configure_uploads` that extracts the
-    configuration for a single set.
-
-    :param uset: The upload set.
-    :param app: The app to load the configuration from.
-    :param defaults: A dict with keys `url` and `dest` from the
-                     `UPLOADS_DEFAULT_DEST` and `DEFAULT_UPLOADS_URL`
-                     settings.
-    """
-    config = app.config
-    prefix = f'UPLOADED_{uset.name.upper()}_'
-    using_defaults = False
-    if defaults is None:
-        defaults = dict(dest=None, url=None)
-
-    allow_extns = tuple(config.get(prefix + "ALLOW", ()))
-    deny_extns = tuple(config.get(prefix + "DENY", ()))
-    destination = config.get(prefix + "DEST")
-    base_url = config.get(prefix + "URL")
-
-    if destination is None:
-        # the upload set's destination wasn't given
-        if uset.default_dest:
-            # use the "default_dest" callable
-            destination = uset.default_dest(app)
-        if destination is None:  # still
-            # use the default dest from the config
-            if defaults["dest"] is not None:
-                using_defaults = True
-                destination = os.path.join(defaults["dest"], uset.name)
-            else:
-                msg = f"no destination for set {uset.name}"
-                raise RuntimeError(msg)
-
-    if base_url is None and using_defaults and defaults["url"]:
-        base_url = addslash(defaults["url"]) + uset.name + "/"
-
-    return UploadConfiguration(destination, base_url, allow_extns, deny_extns)
-
-
-def configure_uploads(app, upload_sets):
-    """
-    Call this after the app has been configured. It will go through all the
-    upload sets, get their configuration, and store the configuration on the
-    app. It will also register the uploads module if it hasn't been set. This
-    can be called multiple times with different upload sets.
-
-    .. versionchanged:: 0.1.3
-       The uploads module/blueprint will only be registered if it is needed
-       to serve the upload sets.
-
-    :param app: The `~flask.Flask` instance to get the configuration from.
-    :param upload_sets: The `UploadSet` instances to configure.
-    """
-    if isinstance(upload_sets, UploadSet):
-        upload_sets = (upload_sets,)
-
-    if not hasattr(app, "upload_set_config"):
-        app.upload_set_config = {}
-    set_config = app.upload_set_config
-    defaults = dict(
-        dest=app.config.get("UPLOADS_DEFAULT_DEST"),
-        url=app.config.get("UPLOADS_DEFAULT_URL"),
-    )
-
-    for uset in upload_sets:
-        config = config_for_set(uset, app, defaults)
-        set_config[uset.name] = config
-
-    should_serve = any(s.base_url is None for s in set_config.values())
-    if "_uploads" not in app.blueprints and should_serve:
-        app.register_blueprint(uploads_mod)
-
-
-class All(object):
-    """
-    This type can be used to allow all extensions. There is a predefined
-    instance named `ALL`.
-    """
-
-    def __contains__(self, item):
-        return True
-
-
-#: This "contains" all items. You can use it to allow all extensions to be
-#: uploaded.
-ALL = All()
-
-
-class AllExcept(object):
-    """
-    This can be used to allow all file types except certain ones. For example,
-    to ban .exe and .iso files, pass::
-
-        AllExcept(('exe', 'iso'))
-
-    to the `UploadSet` constructor as `extensions`. You can use any container,
-    for example::
-
-        AllExcept(SCRIPTS + EXECUTABLES)
-    """
-
-    def __init__(self, items):
-        self.items = items
-
-    def __contains__(self, item):
-        return item not in self.items
-
-
-class UploadConfiguration(object):
-    """
-    This holds the configuration for a single `UploadSet`. The constructor's
-    arguments are also the attributes.
-
-    :param destination: The directory to save files to.
-    :param base_url: The URL (ending with a /) that files can be downloaded
-                     from. If this is `None`, Flask-Uploads will serve the
-                     files itself.
-    :param allow: A list of extensions to allow, even if they're not in the
-                  `UploadSet` extensions list.
-    :param deny: A list of extensions to deny, even if they are in the
-                 `UploadSet` extensions list.
-    """
-
-    def __init__(self, destination, base_url=None, allow=(), deny=()):
-        self.destination = destination
-        self.base_url = base_url
-        self.allow = allow
-        self.deny = deny
-
-    @property
-    def tuple(self):
-        return (self.destination, self.base_url, self.allow, self.deny)
-
-    def __eq__(self, other):
-        return self.tuple == other.tuple
-
-
-class UploadSet(object):
-    """
-    This represents a single set of uploaded files. Each upload set is
-    independent of the others. This can be reused across multiple application
-    instances, as all configuration is stored on the application object itself
-    and found with `flask.current_app`.
-
-    :param name: The name of this upload set. It defaults to ``files``, but
-                 you can pick any alphanumeric name you want. (For simplicity,
-                 it's best to use a plural noun.)
-    :param extensions: The extensions to allow uploading in this set. The
-                       easiest way to do this is to add together the extension
-                       presets (for example, ``TEXT + DOCUMENTS + IMAGES``).
-                       It can be overridden by the configuration with the
-                       `UPLOADED_X_ALLOW` and `UPLOADED_X_DENY` configuration
-                       parameters. The default is `DEFAULTS`.
-    :param default_dest: If given, this should be a callable. If you call it
-                         with the app, it should return the default upload
-                         destination path for that app.
-    """
-
-    def __init__(self, name="files", extensions=DEFAULTS, default_dest=None):
-        if not name.isalnum():
-            raise ValueError("Name must be alphanumeric (no underscores)")
-        self.name = name
-        self.extensions = extensions
-        self._config = None
-        self.default_dest = default_dest
-
-    @property
-    def config(self):
-        """
-        This gets the current configuration. By default, it looks up the
-        current application and gets the configuration from there. But if you
-        don't want to go to the full effort of setting an application, or it's
-        otherwise outside of a request context, set the `_config` attribute to
-        an `UploadConfiguration` instance, then set it back to `None` when
-        you're done.
-        """
-        if self._config is not None:
-            return self._config
-        try:
-            return current_app.upload_set_config[self.name]
-        except AttributeError:
-            raise RuntimeError("cannot access configuration outside request")
-
-    def url(self, filename):
-        """
-        This function gets the URL a file uploaded to this set would be
-        accessed at. It doesn't check whether said file exists.
-
-        :param filename: The filename to return the URL for.
-        """
-        base = self.config.base_url
-        if base is None:
-            return url_for(
-                "_uploads.uploaded_file",
-                setname=self.name,
-                filename=filename,
-                _external=True,
-            )
-        return base + filename
-
-    def path(self, filename, folder=None):
-        """
-        This returns the absolute path of a file uploaded to this set. It
-        doesn't actually check whether said file exists.
-
-        :param filename: The filename to return the path for.
-        :param folder: The subfolder within the upload set previously used
-                       to save to.
-        """
-        if folder is not None:
-            target_folder = os.path.join(self.config.destination, folder)
-        else:
-            target_folder = self.config.destination
-        return os.path.join(target_folder, filename)
-
-    def file_allowed(self, storage, basename):
-        """
-        This tells whether a file is allowed. It should return `True` if the
-        given `werkzeug.FileStorage` object can be saved with the given
-        basename, and `False` if it can't. The default implementation just
-        checks the extension, so you can override this if you want.
-
-        :param storage: The `werkzeug.FileStorage` to check.
-        :param basename: The basename it will be saved under.
-        """
-        return self.extension_allowed(extension(basename))
-
-    def extension_allowed(self, ext):
-        """
-        This determines whether a specific extension is allowed. It is called
-        by `file_allowed`, so if you override that but still want to check
-        extensions, call back into this.
-
-        :param ext: The extension to check, without the dot.
-        """
-        return (ext in self.config.allow) or (
-            ext in self.extensions and ext not in self.config.deny
-        )
-
-    def get_basename(self, filename):
-        return lowercase_ext(secure_filename(filename))
-
-    def save(self, storage, folder=None, name=None):
-        """
-        This saves a `werkzeug.FileStorage` into this upload set. If the
-        upload is not allowed, an `UploadNotAllowed` error will be raised.
-        Otherwise, the file will be saved and its name (including the folder)
-        will be returned.
-
-        :param storage: The uploaded file to save.
-        :param folder: The subfolder within the upload set to save to.
-        :param name: The name to save the file as. If it ends with a dot, the
-                     file's extension will be appended to the end. (If you
-                     are using `name`, you can include the folder in the
-                     `name` instead of explicitly using `folder`, i.e.
-                     ``uset.save(file, name="someguy/photo_123.")``
-        """
-        if not isinstance(storage, FileStorage):
-            raise TypeError("storage must be a werkzeug.FileStorage")
-
-        if folder is None and name is not None and "/" in name:
-            folder, name = os.path.split(name)
-
-        basename = self.get_basename(storage.filename)
-
-        if not self.file_allowed(storage, basename):
-            raise UploadNotAllowed()
-
-        if name:
-            basename = name + extension(basename) if name.endswith(".") else name
-
-        if folder:
-            target_folder = os.path.join(self.config.destination, folder)
-        else:
-            target_folder = self.config.destination
-        if not os.path.exists(target_folder):
-            os.makedirs(target_folder)
-        if os.path.exists(os.path.join(target_folder, basename)):
-            basename = self.resolve_conflict(target_folder, basename)
-
-        target = os.path.join(target_folder, basename)
-        storage.save(target)
-        return posixpath.join(folder, basename) if folder else basename
-
-    def resolve_conflict(self, target_folder, basename):
-        """
-        If a file with the selected name already exists in the target folder,
-        this method is called to resolve the conflict. It should return a new
-        basename for the file.
-
-        The default implementation splits the name and extension and adds a
-        suffix to the name consisting of an underscore and a number, and tries
-        that until it finds one that doesn't exist.
-
-        :param target_folder: The absolute path to the target.
-        :param basename: The file's original basename.
-        """
-        name, ext = os.path.splitext(basename)
-        count = 0
-        while True:
-            count = count + 1
-            newname = "%s_%d%s" % (name, count, ext)
-            if not os.path.exists(os.path.join(target_folder, newname)):
-                return newname
-
-
-uploads_mod = Blueprint("_uploads", __name__, url_prefix="/_uploads")
-
-
-@uploads_mod.route("/<setname>/<path:filename>")
-def uploaded_file(setname, filename):
-    config = current_app.upload_set_config.get(setname)
-    if config is None:
-        abort(404)
-    return send_from_directory(config.destination, filename)
-
-
-class TestingFileStorage(FileStorage):
-    """
-    This is a helper for testing upload behavior in your application. You
-    can manually create it, and its save method is overloaded to set `saved`
-    to the name of the file it was saved to. All of these parameters are
-    optional, so only bother setting the ones relevant to your application.
-
-    :param stream: A stream. The default is an empty stream.
-    :param filename: The filename uploaded from the client. The default is the
-                     stream's name.
-    :param name: The name of the form field it was loaded from. The default is
-                 `None`.
-    :param content_type: The content type it was uploaded as. The default is
-                         ``application/octet-stream``.
-    :param content_length: How long it is. The default is -1.
-    :param headers: Multipart headers as a `werkzeug.Headers`. The default is
-                    `None`.
-    """
-
-    def __init__(
-        self,
-        stream=None,
-        filename=None,
-        name=None,
-        content_type="application/octet-stream",
-        content_length=-1,
-        headers=None,
-    ):
-        FileStorage.__init__(
-            self,
-            stream,
-            filename,
-            name=name,
-            content_type=content_type,
-            content_length=content_length,
-            headers=None,
-        )
-        self.saved = None
-
-    def save(self, dst, buffer_size=16384):
-        """
-        This marks the file as saved by setting the `saved` attribute to the
-        name of the file it was saved to.
-
-        :param dst: The file to save to.
-        :param buffer_size: Ignored.
-        """
-        self.saved = dst if isinstance(dst, string_types) else dst.name