psdi-data-conversion 0.0.35__py3-none-any.whl → 0.0.37__py3-none-any.whl

psdi_data_conversion/app.py

@@ -5,6 +5,7 @@ Version 1.0, 8th November 2024
 This script acts as a server for the PSDI Data Conversion Service website.
 """
 
+from argparse import ArgumentParser
 import hashlib
 import os
 import json
@@ -14,6 +15,7 @@ import sys
 import traceback
 from flask import Flask, request, render_template, abort, Response
 
+import psdi_data_conversion
 from psdi_data_conversion import log_utility
 from psdi_data_conversion import constants as const
 from psdi_data_conversion.converter import run_converter
@@ -63,6 +65,20 @@ else:
         print(f"ERROR: {str(e)}")
         exit(1)
 
+# 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:
+    max_file_size = float(ev_max_file_size)*const.MEGABYTE
+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
+
 app = Flask(__name__)
 
 
@@ -95,15 +111,10 @@ def get_last_sha() -> str:
 def website():
     """Return the web page along with the token
     """
-    # 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:
-        max_file_size = float(ev_max_file_size)*const.MEGABYTE
-    else:
-        max_file_size = const.DEFAULT_MAX_FILE_SIZE
 
     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()}]
@@ -135,7 +146,7 @@ def convert():
                                               data=request.form,
                                               to_format=request.form['to'],
                                               from_format=request.form['from'],
-                                              strict=request.form['check_ext'],
+                                              strict=(request.form['check_ext'] != "false"),
                                               log_mode=log_mode,
                                               log_level=log_level,
                                               delete_input=True,
@@ -150,11 +161,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:
@@ -240,3 +263,80 @@ def data():
     else:
         # return http status code 405
         abort(405)
+
+
+def start_app():
+    """Start the Flask app - this requires being run from the base directory of the project, so this changes the
+    current directory to there. Anything else which changes it while the app is running may interfere with its proper
+    execution.
+    """
+
+    os.chdir(os.path.join(psdi_data_conversion.__path__[0], ".."))
+    app.run()
+
+
+def main():
+    """Standard entry-point function for this script.
+    """
+
+    parser = ArgumentParser()
+
+    parser.add_argument("--use-env-vars", action="store_true",
+                        help="If set, all other arguments and defaults for this script are ignored, and environmental "
+                        "variables and their defaults will instead control execution. These defaults will result in "
+                        "the app running in production server mode.")
+
+    parser.add_argument("--max-file-size", type=float, default=const.DEFAULT_MAX_FILE_SIZE,
+                        help="The maximum allowed filesize in MB - 0 (default) indicates no maximum")
+
+    parser.add_argument("--max-file-size-ob", type=float, default=const.DEFAULT_MAX_FILE_SIZE_OB,
+                        help="The maximum allowed filesize in MB for the Open Babel converter, taking precendence over "
+                        "the general maximum file size when Open Babel is used - 0 indicates no maximum. Default 1 MB.")
+
+    parser.add_argument("--service-mode", action="store_true",
+                        help="If set, will run as if deploying a service rather than the local GUI")
+
+    parser.add_argument("--dev-mode", action="store_true",
+                        help="If set, will expose development elements")
+
+    parser.add_argument("--log-mode", type=str, default=const.LOG_FULL,
+                        help="How logs should be stored. Allowed values are: \n"
+                        "- 'full' - Multi-file logging, not recommended for the CLI, but allowed for a compatible "
+                        "interface with the public web app"
+                        "- 'simple' - Logs saved to one file"
+                        "- 'stdout' - Output logs and errors only to stdout"
+                        "- 'none' - Output only errors to stdout")
+
+    parser.add_argument("--log-level", type=str, default=None,
+                        help="The desired level to log at. Allowed values are: 'DEBUG', 'INFO', 'WARNING', 'ERROR, "
+                             "'CRITICAL'. Default: 'INFO' for logging to file, 'WARNING' for logging to stdout")
+
+    # Set global variables for settings based on parsed arguments, unless it's set to use env vars
+    args = parser.parse_args()
+
+    if not args.use_env_vars:
+
+        global max_file_size
+        max_file_size = args.max_file_size*const.MEGABYTE
+
+        global max_file_size_ob
+        max_file_size_ob = args.max_file_size_ob*const.MEGABYTE
+
+        global service_mode
+        service_mode = args.service_mode
+
+        global production_mode
+        production_mode = not args.dev_mode
+
+        global log_mode
+        log_mode = args.log_mode
+
+        global log_level
+        log_level = args.log_level
+
+    start_app()
+
+
+if __name__ == "__main__":
+
+    main()

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
+                else:
+                    self.max_file_size = const.DEFAULT_MAX_FILE_SIZE
+            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: