psdi-data-conversion 0.0.33__py3-none-any.whl → 0.0.36__py3-none-any.whl

psdi_data_conversion/app.py

@@ -102,8 +102,16 @@ def website():
     else:
         max_file_size = const.DEFAULT_MAX_FILE_SIZE
 
+    # And same for the Open Babel maximum file size
+    ev_max_file_size_ob = os.environ.get(const.MAX_FILESIZE_OB_EV)
+    if ev_max_file_size_ob is not None:
+        max_file_size_ob = float(ev_max_file_size_ob)*const.MEGABYTE
+    else:
+        max_file_size_ob = const.DEFAULT_MAX_FILE_SIZE_OB
+
     data = [{'token': token,
              'max_file_size': max_file_size,
+             'max_file_size_ob': max_file_size_ob,
              'service_mode': service_mode,
              'production_mode': production_mode,
              'sha': get_last_sha()}]
@@ -150,11 +158,23 @@ def convert():
                         fo.write(str(e))
                     abort(const.STATUS_CODE_GENERAL)
 
-            # Failsafe exception message
-            msg = "The following unexpected exception was raised by the converter:\n" + traceback.format_exc()+"\n"
+            # If the exception provides a status code, get it
+            status_code: int
+            if hasattr(e, "status_code"):
+                status_code = e.status_code
+            else:
+                status_code = const.STATUS_CODE_GENERAL
+
+            # If the exception provides a message, report it
+            if hasattr(e, "message"):
+                msg = f"An unexpected exception was raised by the converter, with error message:\n{e.message}\n"
+            else:
+                # Failsafe exception message
+                msg = ("The following unexpected exception was raised by the converter:\n" +
+                       traceback.format_exc()+"\n")
             with open(qualified_output_log, "w") as fo:
                 fo.write(msg)
-            abort(const.STATUS_CODE_GENERAL)
+            abort(status_code)
 
         return repr(conversion_output)
     else:

psdi_data_conversion/constants.py

@@ -40,6 +40,7 @@ CL_SCRIPT_NAME = "psdi-data-convert"
 LOG_MODE_EV = "LOG_MODE"
 LOG_LEVEL_EV = "LOG_LEVEL"
 MAX_FILESIZE_EV = "MAX_FILESIZE"
+MAX_FILESIZE_OB_EV = "MAX_FILESIZE_OB"
 
 # Files and Folders
 # -----------------
@@ -47,6 +48,7 @@ MAX_FILESIZE_EV = "MAX_FILESIZE"
 # Maximum output file size in bytes
 MEGABYTE = 1024*1024
 DEFAULT_MAX_FILE_SIZE = 0*MEGABYTE
+DEFAULT_MAX_FILE_SIZE_OB = 1*MEGABYTE
 
 DEFAULT_UPLOAD_DIR = './psdi_data_conversion/static/uploads'
 DEFAULT_DOWNLOAD_DIR = './psdi_data_conversion/static/downloads'

psdi_data_conversion/converter.py

@@ -17,6 +17,7 @@ from psdi_data_conversion.converters import base
 
 import glob
 
+from psdi_data_conversion.converters.openbabel import CONVERTER_OB
 from psdi_data_conversion.file_io import (is_archive, is_supported_archive, pack_zip_or_tar, split_archive_ext,
                                           unpack_zip_or_tar)
 
@@ -105,7 +106,8 @@ def get_converter(*args, name=const.CONVERTER_DEFAULT, **converter_kwargs) -> ba
     name : str
         The desired converter type, by default 'Open Babel'
     data : dict[str | Any] | None
-        A dict of any other data needed by a converter or for extra logging information, default empty dict
+        A dict of any other data needed by a converter or for extra logging information, default empty dict. See the
+        docstring of each converter for supported keys and values that can be passed to `data` here
     abort_callback : Callable[[int], None]
         Function to be called if the conversion hits an error and must be aborted, default `abort_raise`, which
         raises an appropriate exception
@@ -117,7 +119,9 @@ def get_converter(*args, name=const.CONVERTER_DEFAULT, **converter_kwargs) -> ba
     download_dir : str
         The location of output files relative to the current directory
     max_file_size : float
-        The maximum allowed file size for input/output files, in MB, default 1 MB. If 0, will be unlimited
+        The maximum allowed file size for input/output files, in MB, default 1 MB for Open Babel, unlimited for other
+        converters. If 0, will be unlimited. If an archive of files is provided, this will apply to the total of all
+        files contained in it
     no_check : bool
         If False (default), will check at setup whether or not a conversion between the desired file formats is
         supported with the specified converter
@@ -238,7 +242,7 @@ def run_converter(filename: str,
                   *args,
                   from_format: str | None = None,
                   download_dir=const.DEFAULT_DOWNLOAD_DIR,
-                  max_file_size=const.DEFAULT_MAX_FILE_SIZE,
+                  max_file_size=None,
                   log_file: str | None = None,
                   log_mode=const.LOG_SIMPLE,
                   strict=False,
@@ -261,7 +265,8 @@ def run_converter(filename: str,
     name : str
         The desired converter type, by default 'Open Babel'
     data : dict[str | Any] | None
-        A dict of any other data needed by a converter or for extra logging information, default empty dict
+        A dict of any other data needed by a converter or for extra logging information, default empty dict. See the
+        docstring of each converter for supported keys and values that can be passed to `data` here
     abort_callback : Callable[[int], None]
         Function to be called if the conversion hits an error and must be aborted, default `abort_raise`, which
         raises an appropriate exception
@@ -280,8 +285,9 @@ def run_converter(filename: str,
         into a file of the same format, their logs will be combined into a single log, and the converted files and
         individual logs will be deleted
     max_file_size : float
-        The maximum allowed file size for input/output files, in MB, default 1 MB. If 0, will be unlimited. If an
-        archive of files is provided, this will apply to the total of all files contained in it
+        The maximum allowed file size for input/output files, in MB, default 1 MB for Open Babel, unlimited for other
+        converters. If 0, will be unlimited. If an archive of files is provided, this will apply to the total of all
+        files contained in it
     no_check : bool
         If False (default), will check at setup whether or not a conversion between the desired file formats is
         supported with the specified converter
@@ -318,6 +324,10 @@ def run_converter(filename: str,
         If something goes wrong during the conversion process
     """
 
+    # Set the maximum file size based on which converter is being used if using the default
+    if max_file_size is None:
+        max_file_size = const.DEFAULT_MAX_FILE_SIZE_OB if name == CONVERTER_OB else const.DEFAULT_MAX_FILE_SIZE
+
     # Set the log file if it was unset - note that in server logging mode, this value won't be used within the
     # converter class, so it needs to be set up here to match what will be set up there
     if log_file is None:

psdi_data_conversion/converters/atomsk.py

@@ -11,7 +11,9 @@ CONVERTER_ATO = 'Atomsk'
 
 
 class AtoFileConverter(ScriptFileConverter):
-    """File Converter specialized to use Atomsk for conversions
+    """File Converter specialized to use Atomsk for conversions.
+
+    This converter does not yet support any additional configuration options provided at class init to the `data` kwarg.
     """
 
     name = CONVERTER_ATO

psdi_data_conversion/converters/base.py

@@ -34,7 +34,12 @@ except ImportError:
 class FileConverterException(RuntimeError):
     """Exception class to represent any runtime error encountered by this package.
     """
-    pass
+
+    def __init__(self,
+                 *args,
+                 logged: bool = False):
+        super().__init__(*args)
+        self.logged = logged
 
 
 class FileConverterAbortException(FileConverterException):
@@ -212,7 +217,7 @@ class FileConverter:
                  use_envvars=False,
                  upload_dir=const.DEFAULT_UPLOAD_DIR,
                  download_dir=const.DEFAULT_DOWNLOAD_DIR,
-                 max_file_size=const.DEFAULT_MAX_FILE_SIZE,
+                 max_file_size=None,
                  no_check=False,
                  log_file: str | None = None,
                  log_mode=const.LOG_FULL,
@@ -231,7 +236,8 @@ class FileConverter:
             The format to convert from, as the file extension (e.g. "pdb"). If None is provided (default), will be
             determined from the extension of `filename`
         data : dict[str | Any] | None
-            A dict of any other data needed by a converter or for extra logging information, default empty dict
+            A dict of any other data needed by a converter or for extra logging information, default empty dict. See the
+            docstring of each converter for supported keys and values that can be passed to `data` here
         abort_callback : Callable[[int], None]
             Function to be called if the conversion hits an error and must be aborted, default `abort_raise`, which
             raises an appropriate exception
@@ -275,12 +281,32 @@ class FileConverter:
 
         try:
 
+            if max_file_size is None:
+                from psdi_data_conversion.converters.openbabel import CONVERTER_OB
+                if self.name == CONVERTER_OB:
+                    self.max_file_size = const.DEFAULT_MAX_FILE_SIZE_OB*const.MEGABYTE
+                else:
+                    self.max_file_size = const.DEFAULT_MAX_FILE_SIZE*const.MEGABYTE
+            else:
+                self.max_file_size = max_file_size*const.MEGABYTE
+
+            # Set values from envvars if desired
+            if use_envvars:
+                # Get the maximum allowed size from the envvar for it
+                from psdi_data_conversion.converters.openbabel import CONVERTER_OB
+                if self.name == CONVERTER_OB:
+                    ev_max_file_size = os.environ.get(const.MAX_FILESIZE_OB_EV)
+                else:
+                    ev_max_file_size = os.environ.get(const.MAX_FILESIZE_EV)
+
+                if ev_max_file_size is not None:
+                    self.max_file_size = float(ev_max_file_size)*const.MEGABYTE
+
             # Set member variables directly from input
             self.in_filename = filename
             self.to_format = to_format
             self.upload_dir = upload_dir
             self.download_dir = download_dir
-            self.max_file_size = max_file_size*const.MEGABYTE
             self.log_file = log_file
             self.log_mode = log_mode
             self.log_level = log_level
@@ -312,13 +338,6 @@ class FileConverter:
             self.err: str | None = None
             self.quality: str | None = None
 
-            # Set values from envvars if desired
-            if use_envvars:
-                # Get the maximum allowed size from the envvar for it
-                ev_max_file_size = os.environ.get(const.MAX_FILESIZE_EV)
-                if ev_max_file_size is not None:
-                    self.max_file_size = float(ev_max_file_size)*const.MEGABYTE
-
             # Create directory 'uploads' if not extant.
             if not os.path.exists(self.upload_dir):
                 os.makedirs(self.upload_dir, exist_ok=True)
@@ -351,10 +370,13 @@ class FileConverter:
             self.logger.debug("Finished FileConverter initialisation")
 
         except Exception as e:
+            # Don't catch a deliberate abort; let it pass through
             if isinstance(e, l_abort_exceptions):
-                # Don't catch a deliberate abort; let it pass through
-                self.logger.error(f"Unexpected exception raised while initializing the converter, of type '{type(e)}' "
-                                  f"with message: {str(e)}")
+                if not hasattr(e, "logged") or e.logged is False:
+                    self.logger.error(f"Unexpected exception raised while running the converter, of type '{type(e)}' "
+                                      f"with message: {str(e)}")
+                    if e:
+                        e.logged = True
                 raise
             # Try to run the standard abort method. There's a good chance this will fail though depending on what went
             # wrong when during init, so we fallback to printing the exception to stderr
@@ -362,6 +384,8 @@ class FileConverter:
                 if not isinstance(e, FileConverterHelpException):
                     self.logger.error(f"Exception triggering an abort was raised while initializing the converter. "
                                       f"Exception was type '{type(e)}', with message: {str(e)}")
+                    if e:
+                        e.logged = True
                 self._abort(message="The application encountered an error while initializing the converter:\n" +
                             traceback.format_exc(), e=e)
             except Exception as ee:
@@ -445,20 +469,28 @@ class FileConverter:
         """
 
         try:
+            self.logger.debug("Checking input file size")
+            self._check_input_file_size_and_status()
+
             self.logger.debug("Starting file conversion")
             self._convert()
 
             self.logger.debug("Finished file conversion; performing cleanup tasks")
             self._finish_convert()
         except Exception as e:
+            # Don't catch a deliberate abort; let it pass through
             if isinstance(e, l_abort_exceptions):
-                # Don't catch a deliberate abort; let it pass through
-                self.logger.error(f"Unexpected exception raised while running the converter, of type '{type(e)}' with "
-                                  f"message: {str(e)}")
+                # Log the error if it hasn't yet been logged
+                if not hasattr(e, "logged") or e.logged is False:
+                    self.logger.error(f"Unexpected exception raised while running the converter, of type '{type(e)}' "
+                                      f"with message: {str(e)}")
+                    e.logged = True
                 raise
             if not isinstance(e, FileConverterHelpException):
                 self.logger.error(f"Exception triggering an abort was raised while running the converter. Exception "
                                   f"was type '{type(e)}', with message: {str(e)}")
+                if e:
+                    e.logged = True
             self._abort(message="The application encountered an error while running the converter:\n" +
                         traceback.format_exc(), e=e)
 
@@ -522,13 +554,23 @@ class FileConverter:
             # Note this message in the dev logger as well
             if not isinstance(e, FileConverterHelpException):
                 self.logger.error(message)
+                if e:
+                    e.logged = True
 
-        # Call the abort callback function now. We first try to add information to it, but in case that isn't supported,
-        # we fall back to just calling it with the status code
+        # Call the abort callback function now. We first try passing information to the callback function
         try:
             self.abort_callback(status_code, message, e=e, **kwargs)
         except TypeError:
-            self.abort_callback(status_code)
+            # The callback function doesn't support arguments, so we instead call the callback, catch any exception it
+            # raises, monkey-patch on the extra info, and reraise it
+            try:
+                self.abort_callback(status_code)
+            except Exception as ee:
+                ee.status_code = status_code
+                ee.message = message
+                ee.e = e
+                ee.abort_kwargs = kwargs
+                raise ee
 
     def _abort_from_err(self):
         """Call an abort after a call to the converter has completed, but it's returned an error. Create a message for
@@ -538,7 +580,7 @@ class FileConverter:
                           self._create_message() +
                           self.out + '\n' +
                           self.err)
-        self._abort(message=self.err)
+        self._abort(message=self.err, logged=True)
 
     def _create_message(self) -> str:
         """Create a log of options passed to the converter - this method should be overloaded to log any information
@@ -578,19 +620,38 @@ class FileConverter:
 
         self.logger.info(message)
 
-    def _check_file_size_and_status(self):
-        """Get file sizes, checking that output file isn't too large
+    def _check_input_file_size_and_status(self):
+        """Get input file size and status, checking that the file isn't too large
+        """
 
-        Returns
-        -------
-        in_size : int
-            Size of input file in bytes
-        out_size : int
-            Size of output file in bytes
+        try:
+            self.in_size = os.path.getsize(os.path.realpath(self.in_filename))
+        except FileNotFoundError:
+            # Something went wrong and the output file doesn't exist
+            err_message = f"Expected output file {self.in_filename} does not exist."
+            self.logger.error(err_message)
+            self.err += f"ERROR: {err_message}\n"
+            self._abort_from_err()
+
+        # Check that the input file doesn't exceed the maximum allowed size
+        if self.max_file_size > 0 and self.in_size > self.max_file_size:
+
+            self._abort(const.STATUS_CODE_SIZE,
+                        f"ERROR converting {os.path.basename(self.in_filename)} to " +
+                        os.path.basename(self.out_filename) + ": "
+                        f"Input file exceeds maximum size.\nInput file size is "
+                        f"{self.in_size/const.MEGABYTE:.2f} MB; maximum input file size is "
+                        f"{self.max_file_size/const.MEGABYTE:.2f} MB.\n",
+                        max_file_size=self.max_file_size,
+                        in_size=self.in_size,
+                        out_size=None)
+
+    def _check_output_file_size_and_status(self):
+        """Get output file size and status, checking that the file isn't too large
         """
-        in_size = os.path.getsize(os.path.realpath(self.in_filename))
+
         try:
-            out_size = os.path.getsize(os.path.realpath(self.out_filename))
+            self.out_size = os.path.getsize(os.path.realpath(self.out_filename))
         except FileNotFoundError:
             # Something went wrong and the output file doesn't exist
             err_message = f"Expected output file {self.out_filename} does not exist."
@@ -599,20 +660,19 @@ class FileConverter:
             self._abort_from_err()
 
         # Check that the output file doesn't exceed the maximum allowed size
-        if self.max_file_size > 0 and out_size > self.max_file_size:
+        if self.max_file_size > 0 and self.out_size > self.max_file_size:
 
             self._abort(const.STATUS_CODE_SIZE,
                         f"ERROR converting {os.path.basename(self.in_filename)} to " +
                         os.path.basename(self.out_filename) + ": "
                         f"Output file exceeds maximum size.\nInput file size is "
-                        f"{in_size/const.MEGABYTE:.2f} MB; Output file size is {out_size/const.MEGABYTE:.2f} "
+                        f"{self.in_size/const.MEGABYTE:.2f} MB; Output file size is {self.out_size/const.MEGABYTE:.2f} "
                         f"MB; maximum output file size is {self.max_file_size/const.MEGABYTE:.2f} MB.\n",
-                        in_size=in_size,
-                        out_size=out_size,
-                        max_file_size=self.max_file_size)
-        self.logger.debug(f"Output file found to have size {out_size/const.MEGABYTE:.2f} MB")
+                        max_file_size=self.max_file_size,
+                        in_size=self.in_size,
+                        out_size=self.out_size)
 
-        return in_size, out_size
+        self.logger.debug(f"Output file found to have size {self.out_size/const.MEGABYTE:.2f} MB")
 
     def get_quality(self) -> str:
         """Query the JSON file to obtain conversion quality
@@ -630,7 +690,7 @@ class FileConverter:
         """Run final common steps to clean up a conversion and log success or abort due to an error
         """
 
-        self.in_size, self.out_size = self._check_file_size_and_status()
+        self._check_output_file_size_and_status()
 
         if self.delete_input:
             os.remove(self.in_filename)

psdi_data_conversion/converters/c2x.py

@@ -11,7 +11,9 @@ CONVERTER_C2X = 'c2x'
 
 
 class C2xFileConverter(ScriptFileConverter):
-    """File Converter specialized to use c2x for conversions
+    """File Converter specialized to use c2x for conversions.
+
+    This converter does not yet support any additional configuration options provided at class init to the `data` kwarg.
     """
 
     name = CONVERTER_C2X

psdi_data_conversion/converters/openbabel.py

@@ -76,7 +76,46 @@ def get_coord_gen(l_opts: list[str] | None) -> dict[str, str]:
 
 
 class OBFileConverter(FileConverter):
-    """File Converter specialized to use Open Babel for conversions
+    """File Converter specialized to use Open Babel for conversions.
+
+    This converter supports some additional configuration options which can be provided at class init or call to
+    `run_converter()` through providing a dict to the `data` kwarg. The supported keys and values are:
+
+    "from_flags": str
+        String of concatenated one-letter flags for how to read the input file. To list the flags supported for a given
+        input format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look for the
+        "Allowed input flags" section, if one exists, or alternatively call the library function
+        ``psdi_data_conversion.database.get_in_format_args("Open Babel", <format>)`` from within Python code.
+
+    "to_flags": str
+        String of concatenated one-letter flags for how to write the output file. To list the flags supported for a
+        given output format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look for
+        the "Allowed output flags" section, if one exists, or alternatively call the library function
+        ``psdi_data_conversion.database.get_out_format_args("Open Babel", <format>)`` from within Python code.
+
+    "from_options": str
+        String of space-separated options for how to read the input file. Each option "word" in this string should start
+        with the letter indicating which option is being used, followed by the value for that option. To list the
+        options supported for a given input format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the
+        command-line and look for the "Allowed input options" section, if one exists, or alternatively call the library
+        function ``psdi_data_conversion.database.get_in_format_args("Open Babel", <format>)`` from within Python code.
+
+    "to_options": str
+        String of space-separated options for how to write the output file. Each option "word" in this string should
+        start with the letter indicating which option is being used, followed by the value for that option. To list the
+        options supported for a given output format, call ``psdi-data-convert -l -t <format> -w Open Babel`` at the
+        command-line and look for the "Allowed output options" section, if one exists, or alternatively call the library
+        function ``psdi_data_conversion.database.get_out_format_args("Open Babel", <format>)`` from within Python code.
+
+    "coordinates": str
+        One of "Gen2D", "Gen3D", or "neither", specifying how positional coordinates should be generated in the output
+        file. Default "neither"
+
+    "coordOption": str
+        One of "fastest", "fast", "medium", "better", or "best", specifying the quality of the calculation of
+        coordinates. Default "medium"
+
+    Note that some other keys are supported for compatibility purposes, but these may be deprecated in the future.
     """
 
     name = CONVERTER_OB

psdi_data_conversion/database.py

@@ -284,6 +284,11 @@ class ConverterInfo:
         d_format_args: dict[str | int, set[ArgInfo]] = {}
         l_parent_format_info = self.parent.l_format_info
 
+        # If the converter doesn't provide argument info, set l_arg_info to an empty list so it can be iterated in
+        # the next step, rather than None
+        if not l_arg_info:
+            l_arg_info = []
+
         for arg_info in l_arg_info:
 
             if arg_info is None:

psdi_data_conversion/main.py

@@ -371,7 +371,7 @@ def detail_converter_use(args: ConvertArgs):
             if format_name in l_formats:
                 optional_not: str = ""
             else:
-                optional_not: str = " not"
+                optional_not: str = "not "
             print_wrap(f"Conversion {to_or_from} {format_name} is {optional_not}supported by {args.name}.\n")
 
         # List all possible formats, and which can be used for input and which for output
@@ -551,12 +551,12 @@ def detail_possible_converters(from_format: str, to_format: str):
         return
 
     print_wrap(f"The following registered converters can convert from {from_format} to {to_format}:", newline=True)
-    print("\n    ".join(l_possible_registered_converters))
+    print("    " + "\n    ".join(l_possible_registered_converters) + "\n")
     if l_possible_unregistered_converters:
         print("")
         print_wrap("Additionally, the following converters are supported by this package on other platforms and can "
                    "perform this conversion:", newline=True)
-        print("\n    ".join(l_possible_registered_converters))
+        print("    " + "\n    ".join(l_possible_unregistered_converters) + "\n")
 
     print_wrap("For details on input/output flags and options allowed by a converter for this conversion, call:")
     print(f"{CL_SCRIPT_NAME} -l <converter name> -f {from_format} -t {to_format}")
@@ -694,26 +694,34 @@ def run_from_args(args: ConvertArgs):
                                               delete_input=args.delete_input,
                                               refresh_local_log=False)
         except FileConverterHelpException as e:
-            print_wrap(f"ERROR: {e}", err=True)
+            if not e.logged:
+                print_wrap(f"ERROR: {e}", err=True)
+                e.logged = True
             success = False
             continue
         except FileConverterAbortException as e:
-            print_wrap(f"ERROR: Attempt to convert file {filename} aborted with status code {e.status_code} and "
-                       f"message:\n{e}\n", err=True)
+            if not e.logged:
+                print_wrap(f"ERROR: Attempt to convert file {filename} aborted with status code {e.status_code} and "
+                           f"message:\n{e}\n", err=True)
+                e.logged = True
             success = False
             continue
         except FileConverterInputException as e:
             if "Conversion from" in str(e) and "is not supported" in str(e):
-                print_wrap(f"ERROR: {e}", err=True, newline=True)
+                if not e.logged:
+                    print_wrap(f"ERROR: {e}", err=True, newline=True)
                 detail_possible_converters(args.from_format, args.to_format)
-            else:
+            elif not e.logged:
                 print_wrap(f"ERROR: Attempt to convert file {filename} failed at converter initialization with "
                            f"exception type {type(e)} and message: \n{e}\n", err=True)
+            e.logged = True
             success = False
             continue
         except Exception as e:
-            print_wrap(f"ERROR: Attempt to convert file {filename} failed with exception type {type(e)} and message: " +
-                       f"\n{e}\n", err=True)
+            if not hasattr(e, "logged") or e.logged is False:
+                print_wrap(f"ERROR: Attempt to convert file {filename} failed with exception type {type(e)} and "
+                           f"message: \n{e}\n", err=True)
+                e.logged = True
             success = False
             continue
 

psdi_data_conversion/static/content/accessibility.htm

@@ -15,10 +15,14 @@
   <link href="https://fonts.googleapis.com/css?family=Open+Sans:400" rel="stylesheet" type="text/css">
   <link href="https://fonts.googleapis.com/css?family=Lexend:400" rel="stylesheet" type="text/css">
   <link rel="stylesheet" href="../styles/format.css">
+
+  <script src="https://code.jquery.com/jquery-3.7.1.js" integrity="sha256-eKhayi8LEQwp4NKxN+CfCh+3qOVUtJn3QNZ0TciWLP4="
+    crossorigin="anonymous"></script>
+
   <script src="../javascript/load_accessibility.js"></script>
-  <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.6.3/jquery.min.js"></script>
   <script src="../javascript/common.js" type="module"></script>
   <script src="../javascript/psdi-common.js" type="module"></script>
+  <script src="../javascript/accessibility.js" type="module" language="JavaScript"></script>
 </head>
 
 <body marginwidth="0">
@@ -244,10 +248,6 @@
     </div>
   </form>
 
-  <script src="https://code.jquery.com/jquery-3.7.1.js" integrity="sha256-eKhayi8LEQwp4NKxN+CfCh+3qOVUtJn3QNZ0TciWLP4="
-    crossorigin="anonymous"></script>
-  <script src="../javascript/accessibility.js" type="module" language="JavaScript"></script>
-
   <footer class="footer" id="psdi-footer"></footer>
 
 </body>