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

psdi_data_conversion/testing/gui.py

@@ -0,0 +1,366 @@
+"""
+# gui.py
+
+Utilities to aid in testing of the GUI
+"""
+
+
+import os
+import shutil
+from tempfile import TemporaryDirectory
+
+import time
+import pytest
+from selenium.common.exceptions import TimeoutException
+from selenium.webdriver.common.alert import Alert
+from selenium.webdriver.common.by import By
+from selenium.webdriver.firefox.webdriver import WebDriver
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.select import Select
+from selenium.webdriver.support.ui import WebDriverWait
+
+from psdi_data_conversion.constants import STATUS_CODE_GENERAL
+from psdi_data_conversion.converters.base import (FileConverterAbortException, FileConverterException,
+                                                  FileConverterInputException)
+from psdi_data_conversion.converters.openbabel import (COORD_GEN_KEY, COORD_GEN_QUAL_KEY, DEFAULT_COORD_GEN_QUAL,
+                                                       L_ALLOWED_COORD_GEN_QUALS, L_ALLOWED_COORD_GENS)
+from psdi_data_conversion.file_io import split_archive_ext
+from psdi_data_conversion.testing.utils import (ConversionTestInfo, ConversionTestSpec, SingleConversionTestSpec,
+                                                get_input_test_data_loc)
+
+# Standard timeout at 10 seconds
+TIMEOUT = 10
+
+
+def wait_for_element(root: WebDriver | EC.WebElement, xpath: str, by=By.XPATH):
+    """Shortcut for boilerplate to wait until a web element is visible"""
+    WebDriverWait(root, TIMEOUT).until(EC.element_to_be_clickable((by, xpath)))
+
+
+def wait_and_find_element(root: WebDriver | EC.WebElement, xpath: str, by=By.XPATH) -> EC.WebElement:
+    """Finds a web element, after first waiting to ensure it's visible"""
+    wait_for_element(root, xpath, by=by)
+    return root.find_element(by, xpath)
+
+
+def run_test_conversion_with_gui(test_spec: ConversionTestSpec,
+                                 driver: WebDriver,
+                                 origin: str):
+    """Runs a test conversion or series thereof through the GUI. Note that this requires the server to be started before
+    this is called.
+
+    Parameters
+    ----------
+    test_spec : ConversionTestSpec
+        The specification for the test or series of tests to be run
+    driver : WebDriver
+        The WebDriver to be used for testing
+    origin : str
+        The address of the homepage of the testing server
+    """
+    # Make temporary directories for the input and output files to be stored in
+    with TemporaryDirectory("_input") as input_dir, TemporaryDirectory("_output") as output_dir:
+        # Iterate over the test spec to run each individual test it defines
+        for single_test_spec in test_spec:
+            if single_test_spec.skip:
+                print(f"Skipping single test spec {single_test_spec}")
+                continue
+            print(f"Running single test spec: {single_test_spec}")
+            _run_single_test_conversion_with_gui(test_spec=single_test_spec,
+                                                 input_dir=input_dir,
+                                                 output_dir=output_dir,
+                                                 driver=driver,
+                                                 origin=origin)
+            print(f"Success for test spec: {single_test_spec}")
+
+
+def _run_single_test_conversion_with_gui(test_spec: SingleConversionTestSpec,
+                                         input_dir: str,
+                                         output_dir: str,
+                                         driver: WebDriver,
+                                         origin: str):
+    """Runs a single test conversion through the GUI.
+
+    Parameters
+    ----------
+    test_spec : SingleConversionTestSpec
+        The specification for the test to be run
+    input_dir : str
+        A directory which can be used to store input data before uploading
+    output_dir : str
+        A directory which can be used to create output data after downloading
+    driver : WebDriver
+        The WebDriver to be used for testing
+    origin : str
+        The address of the homepage of the testing server
+    """
+
+    exc_info: pytest.ExceptionInfo | None = None
+    if test_spec.expect_success:
+        try:
+            run_converter_through_gui(test_spec=test_spec,
+                                      input_dir=input_dir,
+                                      output_dir=output_dir,
+                                      driver=driver,
+                                      origin=origin,
+                                      **test_spec.conversion_kwargs)
+            success = True
+        except Exception:
+            print(f"Unexpected exception raised for single test spec {test_spec}")
+            raise
+    else:
+        with pytest.raises(FileConverterException) as exc_info:
+            run_converter_through_gui(test_spec=test_spec,
+                                      input_dir=input_dir,
+                                      output_dir=output_dir,
+                                      driver=driver,
+                                      origin=origin,
+                                      **test_spec.conversion_kwargs)
+        success = False
+
+    # Compile output info for the test and call the callback function if one is provided
+    if test_spec.callback:
+        test_info = ConversionTestInfo(run_type="gui",
+                                       test_spec=test_spec,
+                                       input_dir=input_dir,
+                                       output_dir=output_dir,
+                                       success=success,
+                                       exc_info=exc_info)
+        callback_msg = test_spec.callback(test_info)
+        assert not callback_msg, callback_msg
+
+
+def run_converter_through_gui(test_spec: SingleConversionTestSpec,
+                              input_dir: str,
+                              output_dir: str,
+                              driver: WebDriver,
+                              origin: str,
+                              **conversion_kwargs):
+    """_summary_
+
+    Parameters
+    ----------
+    test_spec : SingleConversionTestSpec
+        The specification for the test to be run
+    input_dir : str
+        The directory which contains the input file
+    output_dir : str
+        The directory which contains the output file
+    driver : WebDriver
+        The WebDriver to be used for testing
+    origin : str
+        The address of the homepage of the testing server
+    """
+
+    # Get just the local filename
+    filename = os.path.split(test_spec.filename)[1]
+
+    # Default options for conversion
+    base_filename, from_format = split_archive_ext(filename)
+    strict = True
+    from_flags: str | None = None
+    to_flags: str | None = None
+    from_options: str | None = None
+    to_options: str | None = None
+    coord_gen = None
+    coord_gen_qual = None
+
+    # For each argument in the conversion kwargs, interpret it as the appropriate option for this conversion, overriding
+    # defaults set above
+    for key, val in conversion_kwargs.items():
+        if key == "from_format":
+            from_format = val
+        elif key == "log_mode":
+            raise ValueError(f"The conversion kwarg {key} is not valid with conversions through the GUI")
+        elif key == "delete_input":
+            raise ValueError(f"The conversion kwarg {key} is not valid with conversions through the GUI")
+        elif key == "strict":
+            strict = val
+        elif key == "max_file_size":
+            raise ValueError(f"The conversion kwarg {key} is not valid with conversions through the GUI")
+        elif key == "data":
+            for subkey, subval in val.items():
+                if subkey == "from_flags":
+                    from_flags = subval
+                elif subkey == "to_flags":
+                    to_flags = subval
+                elif subkey == "from_options":
+                    from_options = subval
+                elif subkey == "to_options":
+                    to_options = subval
+                elif subkey == COORD_GEN_KEY:
+                    coord_gen = subval
+                    if COORD_GEN_QUAL_KEY in val:
+                        coord_gen_qual = val[COORD_GEN_QUAL_KEY]
+                    else:
+                        coord_gen_qual = DEFAULT_COORD_GEN_QUAL
+                elif subkey == COORD_GEN_QUAL_KEY:
+                    # Handled alongside COORD_GEN_KEY above
+                    pass
+                else:
+                    pytest.fail(f"The key 'data[\"{subkey}\"]' was passed to `conversion_kwargs` but could not be "
+                                "interpreted")
+        else:
+            pytest.fail(f"The key '{key}' was passed to `conversion_kwargs` but could not be interpreted")
+
+    # Cleanup of arguments
+    if from_format.startswith("."):
+        from_format = from_format[1:]
+
+    # Set up the input file where we expect it to be
+    source_input_file = os.path.realpath(os.path.join(get_input_test_data_loc(), test_spec.filename))
+    input_file = os.path.join(input_dir, test_spec.filename)
+    if (os.path.isfile(input_file)):
+        os.unlink(input_file)
+    os.symlink(source_input_file, input_file)
+
+    # Remove test files from Downloads directory if they exist.
+
+    log_file = os.path.realpath(os.path.join(os.path.expanduser("~/Downloads"), test_spec.log_filename))
+    if (os.path.isfile(log_file)):
+        os.remove(log_file)
+
+    output_file = os.path.realpath(os.path.join(os.path.expanduser("~/Downloads"), test_spec.out_filename))
+    if (os.path.isfile(output_file)):
+        os.remove(output_file)
+
+    # Get the homepage
+    driver.get(f"{origin}/")
+
+    wait_for_element(driver, "//select[@id='fromList']/option")
+
+    # Select from_format from the 'from' list.
+    driver.find_element(By.XPATH, f"//select[@id='fromList']/option[starts-with(.,'{from_format}:')]").click()
+
+    # Select to_format from the 'to' list.
+    driver.find_element(By.XPATH, f"//select[@id='toList']/option[starts-with(.,'{test_spec.to_format}:')]").click()
+
+    # Select converter from the available conversion options list.
+    driver.find_element(By.XPATH, f"//select[@id='success']/option[contains(.,'{test_spec.converter_name}')]").click()
+
+    # Click on the "Yes" button to accept the converter and go to the conversion page
+    driver.find_element(By.XPATH, "//input[@id='yesButton']").click()
+
+    # Request non-strict filename checking if desired
+    if not strict:
+        wait_and_find_element(driver, "//input[@id='extCheck']").click()
+
+    # Select the input file
+    wait_and_find_element(driver, "//input[@id='fileToUpload']").send_keys(str(input_file))
+
+    # An alert may be present here, which we check for using a try block
+    try:
+        WebDriverWait(driver, 0.2).until(EC.alert_is_present())
+        alert = Alert(driver)
+        alert_text = alert.text
+        alert.dismiss()
+        raise FileConverterInputException(alert_text)
+    except TimeoutException:
+        pass
+
+    # Request the log file
+    wait_and_find_element(driver, "//input[@id='requestLog']").click()
+
+    # Select appropriate format args. The args only have a text attribute, so we need to find the one that starts with
+    # each flag - since we don't have too many, iterating over all possible combinations is the easiest way
+    for (l_flags, select_id) in ((from_flags, "inFlags"),
+                                 (to_flags, "outFlags")):
+        if not l_flags:
+            continue
+        flags_select = Select(wait_and_find_element(driver, f"//select[@id='{select_id}']"))
+        for flag in l_flags:
+            found = False
+            for option in flags_select.options:
+                if option.text.startswith(f"{flag}:"):
+                    flags_select.select_by_visible_text(option.text)
+                    found = True
+                    break
+            if not found:
+                raise ValueError(f"Flag {flag} was not found in {select_id} selection box for conversion from "
+                                 f"{from_format} to {test_spec.to_format} with converter {test_spec.converter_name}")
+
+    for (options_string, table_id) in ((from_options, "in_argFlags"),
+                                       (to_options, "out_argFlags")):
+        if not options_string:
+            continue
+
+        # Split each option into words, of which the first letter of each is the key and the remainder is the value
+        l_options = options_string.split()
+
+        # Get the rows in the options table
+        options_table = wait_and_find_element(driver, f"//table[@id='{table_id}']")
+        l_rows = options_table.find_elements(By.XPATH, "./tr")
+
+        # Look for and set each option
+        for option in l_options:
+            found = False
+            for row in l_rows:
+                l_items = row.find_elements(By.XPATH, "./td")
+                label = l_items[1]
+                if not label.text.startswith(option[0]):
+                    continue
+
+                # Select the option by clicking the box at the first element in the row to make the input appear
+                l_items[0].click()
+
+                # Input the option in the input box that appears in the third position in the row
+                input_box = wait_and_find_element(l_items[2], "./input")
+                input_box.send_keys(option[1:])
+
+                found = True
+                break
+
+            if not found:
+                raise ValueError(f"Option {option} was not found in {table_id} options table for conversion from "
+                                 f"{from_format} to {test_spec.to_format} with converter {test_spec.converter_name}")
+
+    # If radio-button settings are supplied, apply them now
+    for setting, name, l_allowed in ((coord_gen, "coord_gen", L_ALLOWED_COORD_GENS),
+                                     (coord_gen_qual, "coord_gen_qual", L_ALLOWED_COORD_GEN_QUALS)):
+        if not setting:
+            continue
+
+        if setting not in l_allowed:
+            raise ValueError(f"Invalid {name} value supplied: {setting}. Allowed values are: " +
+                             str(l_allowed))
+
+        setting_radio = wait_and_find_element(driver, f"//input[@value='{setting}']")
+        setting_radio.click()
+
+    # Click on the "Convert" button.
+    wait_and_find_element(driver, "//input[@id='uploadButton']").click()
+
+    # Handle alert box.
+    WebDriverWait(driver, TIMEOUT).until(EC.alert_is_present())
+    alert = Alert(driver)
+    alert_text = alert.text
+    alert.dismiss()
+
+    if alert_text.startswith("ERROR:"):
+        # Raise an appropriate exception type depending on if it's a recognised input issue or not
+        if "unexpected exception" in alert_text:
+            raise FileConverterAbortException(STATUS_CODE_GENERAL, alert_text)
+        raise FileConverterInputException(alert_text)
+
+    # Wait until the log file exists, since it's downloaded second
+    time_elapsed = 0
+    while not os.path.isfile(log_file):
+        time.sleep(1)
+        time_elapsed += 1
+        if time_elapsed > TIMEOUT:
+            pytest.fail(f"Download of {output_file} and {log_file} timed out")
+
+    time.sleep(1)
+
+    if not os.path.isfile(output_file):
+        raise FileConverterAbortException("ERROR: No output file was produced. Log contents:\n" +
+                                          open(log_file, "r").read())
+
+    # Move the output file and log file to the expected locations
+    for qual_filename in output_file, log_file:
+        base_filename = os.path.split(qual_filename)[1]
+        target_filename = os.path.join(output_dir, base_filename)
+        if os.path.isfile(target_filename):
+            os.remove(target_filename)
+        if os.path.isfile(qual_filename):
+            shutil.move(qual_filename, target_filename)

psdi_data_conversion/testing/utils.py

@@ -19,19 +19,55 @@ from unittest.mock import patch
 import py
 import pytest
 
+import psdi_data_conversion
 from psdi_data_conversion.constants import CONVERTER_DEFAULT, GLOBAL_LOG_FILENAME, LOG_NONE, OUTPUT_LOG_EXT
 from psdi_data_conversion.converter import run_converter
 from psdi_data_conversion.converters.openbabel import COORD_GEN_KEY, COORD_GEN_QUAL_KEY
 from psdi_data_conversion.dist import LINUX_LABEL, get_dist
 from psdi_data_conversion.file_io import is_archive, split_archive_ext
 from psdi_data_conversion.main import main as data_convert_main
-from psdi_data_conversion.testing.constants import INPUT_TEST_DATA_LOC
+from psdi_data_conversion.testing.constants import (INPUT_TEST_DATA_LOC_IN_PROJECT, OUTPUT_TEST_DATA_LOC_IN_PROJECT,
+                                                    TEST_DATA_LOC_IN_PROJECT)
+
+
+def get_path_in_project(filename):
+    """Get the realpath to a file contained within the project, given its project-relative path"""
+
+    old_cwd = os.getcwd()
+
+    try:
+        os.chdir(os.path.join(psdi_data_conversion.__path__[0], ".."))
+        realpath = os.path.realpath(filename)
+
+    finally:
+        # Change back to the previous directory
+        os.chdir(old_cwd)
+
+    return realpath
+
+
+def get_test_data_loc():
+    """Get the realpath of the base directory containing all data for tests"""
+    return get_path_in_project(TEST_DATA_LOC_IN_PROJECT)
+
+
+def get_input_test_data_loc():
+    """Get the realpath of the base directory containing input data for tests"""
+    return get_path_in_project(INPUT_TEST_DATA_LOC_IN_PROJECT)
+
+
+def get_output_test_data_loc():
+    """Get the realpath of the base directory containing expected output data for tests"""
+    return get_path_in_project(OUTPUT_TEST_DATA_LOC_IN_PROJECT)
 
 
 @dataclass
 class ConversionTestInfo:
     """Information about a tested conversion."""
 
+    run_type: str
+    """One of "library", "cla", or "gui", describing which type of test run was performed"""
+
     test_spec: SingleConversionTestSpec
     """The specification of the test conversion which was run to produce this"""
 
@@ -50,20 +86,23 @@ class ConversionTestInfo:
     captured_stderr: str | None = None
     """Any output to stderr while the test was run"""
 
+    exc_info: pytest.ExceptionInfo | None = None
+    """If the test conversion raised an exception, that exception's info, otherwise None"""
+
     @property
     def qualified_in_filename(self):
         """Get the fully-qualified name of the input file"""
-        return os.path.join(self.input_dir, self.test_spec.filename)
+        return os.path.realpath(os.path.join(self.input_dir, self.test_spec.filename))
 
     @property
     def qualified_out_filename(self):
         """Get the fully-qualified name of the output file"""
-        return os.path.join(self.output_dir, self.test_spec.out_filename)
+        return os.path.realpath(os.path.join(self.output_dir, self.test_spec.out_filename))
 
     @property
     def qualified_log_filename(self):
         """Get the fully-qualified name of the log file"""
-        return os.path.join(self.output_dir, self.test_spec.log_filename)
+        return os.path.realpath(os.path.join(self.output_dir, self.test_spec.log_filename))
 
     @property
     def qualified_global_log_filename(self):
@@ -71,28 +110,6 @@ class ConversionTestInfo:
         return self.test_spec.global_log_filename
 
 
-@dataclass
-class LibraryConversionTestInfo(ConversionTestInfo):
-    """Information about a tested conversion, specifically for when it was tested through a call to the library"""
-
-    exc_info: pytest.ExceptionInfo | None = None
-    """If the test conversion raised an exception, that exception's info, otherwise None"""
-
-
-@dataclass
-class CLAConversionTestInfo(ConversionTestInfo):
-    """Information about a tested conversion, specifically for when it was tested through a the command-line
-    application (CLA)
-    """
-
-
-@dataclass
-class GUIConversionTestInfo(ConversionTestInfo):
-    """Information about a tested conversion, specifically for when it was tested through the GUI (the local version of
-    the web app)
-    """
-
-
 @dataclass
 class ConversionTestSpec:
     """Class providing a specification for a test file conversion.
@@ -121,6 +138,11 @@ class ConversionTestSpec:
     expect_success: bool | Iterable[bool] = True
     """Whether or not to expect the test to succeed"""
 
+    skip: bool | Iterable[bool] = False
+    """If set to true, this test will be skipped and not run. Can also be set individually for certain tests within an
+    array. This should typically only be used when debugging to skip working tests to more easily focus on non-working
+    tests"""
+
     callback: (Callable[[ConversionTestInfo], str] |
                Iterable[Callable[[ConversionTestInfo], str]] | None) = None
     """Function to be called after the conversion is performed to check in detail whether results are as expected. It
@@ -187,6 +209,9 @@ class ConversionTestSpec:
             if attr_name in l_single_val_attrs:
                 setattr(self, attr_name, [getattr(self, attr_name)]*self._len)
 
+        # Check if all tests should be skipped
+        self.skip_all = all(self.skip)
+
     def __len__(self):
         """Get the length from the member - valid only after `__post_init__` has been called"""
         return self._len
@@ -221,6 +246,9 @@ class SingleConversionTestSpec:
     expect_success: bool = True
     """Whether or not to expect the test to succeed"""
 
+    skip: bool = False
+    """If set to True, this test will be skipped, always returning success"""
+
     callback: (Callable[[ConversionTestInfo], str] | None) = None
     """Function to be called after the conversion is performed to check in detail whether results are as expected. It
     should take as its only argument a `ConversionTestInfo` and return a string. The string should be empty if the check
@@ -258,9 +286,14 @@ def run_test_conversion_with_library(test_spec: ConversionTestSpec):
     with TemporaryDirectory("_input") as input_dir, TemporaryDirectory("_output") as output_dir:
         # Iterate over the test spec to run each individual test it defines
         for single_test_spec in test_spec:
+            if single_test_spec.skip:
+                print(f"Skipping single test spec {single_test_spec}")
+                continue
+            print(f"Running single test spec: {single_test_spec}")
             _run_single_test_conversion_with_library(test_spec=single_test_spec,
                                                      input_dir=input_dir,
                                                      output_dir=output_dir)
+            print(f"Success for test spec: {single_test_spec}")
 
 
 def _run_single_test_conversion_with_library(test_spec: SingleConversionTestSpec,
@@ -279,9 +312,9 @@ def _run_single_test_conversion_with_library(test_spec: SingleConversionTestSpec
     """
 
     # Symlink the input file to the input directory
-    qualified_in_filename = os.path.join(input_dir, test_spec.filename)
+    qualified_in_filename = os.path.realpath(os.path.join(input_dir, test_spec.filename))
     try:
-        os.symlink(os.path.join(INPUT_TEST_DATA_LOC, test_spec.filename),
+        os.symlink(os.path.join(get_input_test_data_loc(), test_spec.filename),
                    qualified_in_filename)
     except FileExistsError:
         pass
@@ -316,13 +349,14 @@ def _run_single_test_conversion_with_library(test_spec: SingleConversionTestSpec
 
     # Compile output info for the test and call the callback function if one is provided
     if test_spec.callback:
-        test_info = LibraryConversionTestInfo(test_spec=test_spec,
-                                              input_dir=input_dir,
-                                              output_dir=output_dir,
-                                              success=success,
-                                              captured_stdout=stdout,
-                                              captured_stderr=stderr,
-                                              exc_info=exc_info)
+        test_info = ConversionTestInfo(run_type="library",
+                                       test_spec=test_spec,
+                                       input_dir=input_dir,
+                                       output_dir=output_dir,
+                                       success=success,
+                                       captured_stdout=stdout,
+                                       captured_stderr=stderr,
+                                       exc_info=exc_info)
         callback_msg = test_spec.callback(test_info)
         assert not callback_msg, callback_msg
 
@@ -339,9 +373,14 @@ def run_test_conversion_with_cla(test_spec: ConversionTestSpec):
     with TemporaryDirectory("_input") as input_dir, TemporaryDirectory("_output") as output_dir:
         # Iterate over the test spec to run each individual test it defines
         for single_test_spec in test_spec:
+            if single_test_spec.skip:
+                print(f"Skipping single test spec {single_test_spec}")
+                continue
+            print(f"Running single test spec: {single_test_spec}")
             _run_single_test_conversion_with_cla(test_spec=single_test_spec,
                                                  input_dir=input_dir,
                                                  output_dir=output_dir)
+            print(f"Success for test spec: {single_test_spec}")
 
 
 def _run_single_test_conversion_with_cla(test_spec: SingleConversionTestSpec,
@@ -360,9 +399,9 @@ def _run_single_test_conversion_with_cla(test_spec: SingleConversionTestSpec,
     """
 
     # Symlink the input file to the input directory
-    qualified_in_filename = os.path.join(input_dir, test_spec.filename)
+    qualified_in_filename = os.path.realpath(os.path.join(input_dir, test_spec.filename))
     try:
-        os.symlink(os.path.join(INPUT_TEST_DATA_LOC, test_spec.filename),
+        os.symlink(os.path.join(get_input_test_data_loc(), test_spec.filename),
                    qualified_in_filename)
     except FileExistsError:
         pass
@@ -392,7 +431,7 @@ def _run_single_test_conversion_with_cla(test_spec: SingleConversionTestSpec,
             # Get the success from whether or not the exit code is 0
             success = not exc_info.value.code
 
-        qualified_out_filename = os.path.join(output_dir, test_spec.out_filename)
+        qualified_out_filename = os.path.realpath(os.path.join(output_dir, test_spec.out_filename))
 
         # Determine success based on whether or not the output file exists with non-zero size
         if not os.path.isfile(qualified_out_filename) or os.path.getsize(qualified_out_filename) == 0:
@@ -405,12 +444,13 @@ def _run_single_test_conversion_with_cla(test_spec: SingleConversionTestSpec,
 
     # Compile output info for the test and call the callback function if one is provided
     if test_spec.callback:
-        test_info = CLAConversionTestInfo(test_spec=test_spec,
-                                          input_dir=input_dir,
-                                          output_dir=output_dir,
-                                          success=success,
-                                          captured_stdout=stdout,
-                                          captured_stderr=stderr)
+        test_info = ConversionTestInfo(run_type="cla",
+                                       test_spec=test_spec,
+                                       input_dir=input_dir,
+                                       output_dir=output_dir,
+                                       success=success,
+                                       captured_stdout=stdout,
+                                       captured_stderr=stderr)
         callback_msg = test_spec.callback(test_info)
         assert not callback_msg, callback_msg
 
@@ -441,6 +481,8 @@ def run_converter_through_cla(filename: str,
         The directory which contains the output file
     log_file : str
         The desired name of the log file
+    conversion_kwargs : Any
+        Additional arguments describing the conversion
     """
 
     # Start the argument string with the arguments we will always include