psdi-data-conversion 0.0.36__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,19 +111,6 @@ 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
-
-    # 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,
@@ -143,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,
@@ -260,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/converters/base.py

@@ -284,9 +284,9 @@ class FileConverter:
             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
+                    self.max_file_size = const.DEFAULT_MAX_FILE_SIZE_OB
                 else:
-                    self.max_file_size = const.DEFAULT_MAX_FILE_SIZE*const.MEGABYTE
+                    self.max_file_size = const.DEFAULT_MAX_FILE_SIZE
             else:
                 self.max_file_size = max_file_size*const.MEGABYTE
 

psdi_data_conversion/static/content/download.htm

@@ -43,6 +43,8 @@
         Python library.
       </p>
 
+      <h2>Installation</h2>
+
       <h3>Install via pip</h3>
 
       <ul>
@@ -63,12 +65,6 @@
         Python library.
       </p>
 
-      <p>
-        If you do wish to run the local version of this webpage, you'll need to create a helper script to set up the
-        proper parameters and start the server. See the README provided on the front page of this project's PyPI page,
-        linked above, for the source of this helper script, which you can paste and use locally.
-      </p>
-
       <h3>Source Code</h3>
 
       <ul>
@@ -86,11 +82,28 @@
         for other possible optional dependencies sets that can be installed.
       </p>
 
-      <p>When installed in this manner, the helper script to run the local webpage is provided in the root directory
-        of the repository as <code class="secondary">run_local.sh</code>. It can be run from this directory, copied to
-        your <code class="secondary">$PATH</code>, or aliased as desired.
+      <h2>Use</h2>
+
+      <p>
+        Once installed, the project can be used in one of three ways:
       </p>
 
+      <ul>
+        <li><strong>Local Gui:</strong> Run the script <code class="secondary">psdi-data-convert-gui</code> to start the
+          server. Append the <code class="secondary">--help</code> option for to see optional arguments (generally not
+          required for end-users)
+        </li>
+        <li><strong>Command-Line Application:</strong> Run the script <code class="secondary">psdi-data-convert</code>
+          to use the application at the command-line. Append the <code class="secondary">--help</code> option to see
+          arguments for it, and/or find documentation in the project's README.
+        </li>
+        <li><strong>Python Library:</strong> Within a Python script, library, or terminal, the project can be imported
+          via <code class="secondary">import psdi_data_conversion</code>, with the most useful function being <code
+            class="secondary">psdi_data_conversion.converter.run_converter</code> - see the <code
+            class="secondary">help()</code> of this function and/or find documentation in the project's README.
+        </li>
+      </ul>
+
       <h2>Documentation</h2>
 
       <ul>

psdi_data_conversion/static/styles/psdi-common.css

@@ -228,7 +228,7 @@ body {
   top       : 0;
   left      : 0;
   background: var(--ifm-background-color);
-  z-index   : 9999;
+  z-index   : 99999;
 }
 
 select,
@@ -412,7 +412,8 @@ h6 {
 }
 
 p {
-  margin: 0 0 1.25rem 0;
+  margin        : 0 0 1.25rem 0;
+  padding-bottom: 0;
 }
 
 .text--center {
@@ -546,9 +547,9 @@ a svg {
 }
 
 .navbar__title h5 {
-  display: unset;
+  display: flex;
   color  : var(--ifm-heading-color);
-  margin : 0 0 0.5rem 0.5rem;
+  margin : 0 0 0.5rem 1.5rem;
 }
 
 .navbar__logo img {

psdi_data_conversion/templates/index.htm

@@ -57,6 +57,11 @@
 
   <form name="gui" class="gui">
     <div class="max-width-box">
+      <p>Your one-stop shop for file format conversion, PSDI's Data Conversion Service enables users to seamlessly
+        convert between different file formats and assess the quality of proposed conversions. This is the web version
+        of our service. To find out more about Data Conversion and our other tools, click
+        <a href="https://resources.psdi.ac.uk/resource-themes/7bcc430a-fdc9-413e-bf32-bf163236430b"
+          id="more" target="_blank">here.</a></p>
       <p>Select 'from' and 'to' file formats in the 'Convert from/to' boxes, in either order. Typing where indicated
         filters the options (case insensitive); for example, typing 'can' or 'NON' reduces the number of options to one:
         'can: Canonical SMILES.' If you change your mind about a conversion, it is advisable to click on the 'Reset'
@@ -118,4 +123,4 @@
 
 </body>
 
-</html>
+</html>

psdi_data_conversion/testing/constants.py

@@ -6,7 +6,10 @@ Constants related to unit testing
 
 import os
 
-TEST_DATA_LOC = os.path.abspath("./test_data")
+# Locations relative to the root directory of the project - to ensure the files are found, tests should chdir to this
+# directory before searching for files
 
-INPUT_TEST_DATA_LOC = TEST_DATA_LOC
-OUTPUT_TEST_DATA_LOC = os.path.join(TEST_DATA_LOC, "output")
+TEST_DATA_LOC_IN_PROJECT = "./test_data"
+
+INPUT_TEST_DATA_LOC_IN_PROJECT = TEST_DATA_LOC_IN_PROJECT
+OUTPUT_TEST_DATA_LOC_IN_PROJECT = os.path.join(TEST_DATA_LOC_IN_PROJECT, "output")

psdi_data_conversion/testing/conversion_callbacks.py

@@ -15,8 +15,8 @@ from tempfile import TemporaryDirectory
 from psdi_data_conversion.constants import DATETIME_RE_RAW
 from psdi_data_conversion.file_io import unpack_zip_or_tar
 from psdi_data_conversion.log_utility import string_with_placeholders_matches
-from psdi_data_conversion.testing.constants import OUTPUT_TEST_DATA_LOC
-from psdi_data_conversion.testing.utils import ConversionTestInfo, LibraryConversionTestInfo, check_file_match
+from psdi_data_conversion.testing.constants import OUTPUT_TEST_DATA_LOC_IN_PROJECT
+from psdi_data_conversion.testing.utils import ConversionTestInfo, check_file_match
 
 
 class MultiCallback:
@@ -326,7 +326,7 @@ class CheckException:
     """Callable class which checks an exception raised for its type, status code, and message. Tests will only be
     run on tests with the python library, as that's the only route that provides exceptions."""
 
-    ex_type: type[Exception]
+    ex_type: type[Exception] | None = None
     """The expected type of the raised exception (subclasses of it will also be allowed)"""
 
     ex_message: str | None = None
@@ -339,7 +339,8 @@ class CheckException:
     def __call__(self, test_info: ConversionTestInfo) -> str:
         """Perform the check on the exception"""
 
-        if not isinstance(test_info, LibraryConversionTestInfo):
+        # Skip check on CLA, since this won't catch any exceptions
+        if test_info.run_type == "cla":
             return ""
 
         # Confirm that an exception was indeed raised
@@ -350,7 +351,7 @@ class CheckException:
         l_errors: list[str] = []
 
         # Check the exception type
-        if not issubclass(exc_info.type, self.ex_type):
+        if self.ex_type and not issubclass(exc_info.type, self.ex_type):
             l_errors.append(f"ERROR: Raised exception is of type '{exc_info.type}', but expected '{self.ex_type}'")
 
         exc = exc_info.value
@@ -389,6 +390,6 @@ class MatchOutputFile:
     def __call__(self, test_info: ConversionTestInfo):
         """Run the check comparing the two files"""
 
-        qualified_ex_output_filename = os.path.join(OUTPUT_TEST_DATA_LOC, self.ex_output_filename)
+        qualified_ex_output_filename = os.path.join(OUTPUT_TEST_DATA_LOC_IN_PROJECT, self.ex_output_filename)
 
         return check_file_match(test_info.qualified_out_filename, qualified_ex_output_filename)

psdi_data_conversion/testing/conversion_test_specs.py

@@ -22,18 +22,26 @@ from psdi_data_conversion.testing.utils import ConversionTestSpec as Spec
 l_all_test_specs: list[Spec] = []
 """All test specs defined in this file"""
 
-l_all_test_specs.append(Spec(name="Basic",
-                             filename=["1NE6.mmcif", "standard_test.cdxml",
+l_all_test_specs.append(Spec(name="Standard Single Test",
+                             filename="standard_test.cdxml",
+                             to_format="inchi",
+                             callback=MCB(CheckFileStatus(),
+                                          CheckLogContentsSuccess(),
+                                          MatchOutputFile("standard_test.inchi")),
+                             ))
+
+l_all_test_specs.append(Spec(name="Standard Multiple Tests",
+                             filename=["1NE6.mmcif",
                                        "hemoglobin.pdb", "aceticacid.mol", "nacl.cif",
                                        "hemoglobin.pdb", "hemoglobin.pdb", "nacl.cif",
                                        "hemoglobin.pdb", "hemoglobin.pdb", "nacl.cif",
                                        "ethanol.xyz"],
-                             to_format=["pdb", "inchi",
+                             to_format=["pdb",
                                         "cif", "mol2", "xyz",
                                         "cif", "xyz", "xyz",
                                         "cif", "xyz", "xyz",
                                         "cml"],
-                             converter_name=[CONVERTER_OB, CONVERTER_OB,
+                             converter_name=[CONVERTER_OB,
                                              CONVERTER_OB, CONVERTER_OB, CONVERTER_OB,
                                              CONVERTER_ATO, CONVERTER_ATO, CONVERTER_ATO,
                                              CONVERTER_C2X, CONVERTER_C2X, CONVERTER_C2X,
@@ -57,12 +65,13 @@ l_all_test_specs.append(Spec(name="Archive",
                              filename=["caffeine-smi.zip",
                                        "caffeine-smi.tar",
                                        "caffeine-smi.tar.gz"],
+                             conversion_kwargs={"from_format": "smi"},
                              to_format="inchi",
                              callback=archive_callback,
                              ))
 """A test of converting a archives of files"""
 
-l_all_test_specs.append(Spec(name="Archive (wrong format)",
+l_all_test_specs.append(Spec(name="Archive (wrong format) - Library and CLA",
                              filename="caffeine-smi.zip",
                              to_format="inchi",
                              conversion_kwargs=[{"from_format": "pdb"},
@@ -71,10 +80,27 @@ l_all_test_specs.append(Spec(name="Archive (wrong format)",
                              callback=[CheckStderrContents(const.ERR_WRONG_EXTENSIONS),
                                        CheckException(ex_type=FileConverterInputException,
                                                       ex_message=const.ERR_WRONG_EXTENSIONS)],
+                             compatible_with_gui=False,
                              ))
 """A test that if the user provides the wrong input format for files in an archive, and error will be output to stderr
 """
 
+l_all_test_specs.append(Spec(name="Archive (wrong format) - GUI",
+                             filename="caffeine-smi.zip",
+                             to_format="inchi",
+                             conversion_kwargs=[{"from_format": "pdb"},
+                                                {"from_format": "pdb", "strict": True}],
+                             expect_success=[False, False],
+                             callback=CheckException(ex_type=FileConverterInputException,
+                                                     ex_message=const.ERR_WRONG_EXTENSIONS),
+                             compatible_with_library=False,
+                             compatible_with_cla=False,
+                             ))
+"""A test that if the user provides the wrong input format for files in an archive - variant for the GUI test, which is
+more strict
+"""
+
+
 l_all_test_specs.append(Spec(name="Log mode",
                              conversion_kwargs=[{"log_mode": const.LOG_NONE},
                                                 {"log_mode": const.LOG_STDOUT},
@@ -138,8 +164,12 @@ l_all_test_specs.append(Spec(name="Invalid Converter",
                              converter_name="INVALID",
                              expect_success=False,
                              callback=invalid_converter_callback,
+                             compatible_with_gui=False,
                              ))
-"""A test that a proper error is returned if an invalid converter is requested"""
+"""A test that a proper error is returned if an invalid converter is requested
+
+Not compatible with GUI tests, since the GUI only offers valid converters to choose from
+"""
 
 quartz_quality_note_callback = CheckLogContentsSuccess(["WARNING",
                                                         const.QUAL_NOTE_OUT_MISSING.format(const.QUAL_2D_LABEL),
@@ -165,8 +195,12 @@ output and will be lost"""
 l_all_test_specs.append(Spec(name="Cleanup input",
                              conversion_kwargs={"delete_input": True},
                              callback=CheckFileStatus(expect_input_exists=False),
+                             compatible_with_gui=False,
                              ))
-"""A test that the input file to a conversion is deleted when cleanup is requested"""
+"""A test that the input file to a conversion is deleted when cleanup is requested.
+
+Not compatible with the GUI, since the GUI can't forcibly delete files uploaded from the user's computer
+"""
 
 l_all_test_specs.append(Spec(name="Failed conversion - bad input file",
                              filename=["quartz_err.xyz", "cyclopropane_err.mol"],
@@ -186,14 +220,29 @@ l_all_test_specs.append(Spec(name="Failed conversion - bad input file",
 
 quartz_error_ob_callback = CheckLogContents(["ERROR",
                                              "Problems reading an XYZ file: Could not read line #11, file error"])
-l_all_test_specs.append(Spec(name="Errors in logs",
+l_all_test_specs.append(Spec(name="Errors in logs - Library and CLA",
                              filename="quartz_err.xyz",
                              to_format="inchi",
                              converter_name=CONVERTER_OB,
                              expect_success=False,
                              callback=quartz_error_ob_callback,
+                             compatible_with_gui=False,
+                             ))
+"""A test that when a conversion fails in the library or CLA, logs are still produced and contain the expected error
+message"""
+
+l_all_test_specs.append(Spec(name="Errors in logs - GUI",
+                             filename="quartz_err.xyz",
+                             to_format="inchi",
+                             converter_name=CONVERTER_OB,
+                             expect_success=False,
+                             callback=CheckException(ex_type=FileConverterAbortException,
+                                                     ex_message=("Problems reading an XYZ file: Could not read line "
+                                                                 "#11, file error")),
+                             compatible_with_library=False,
+                             compatible_with_cla=False,
                              ))
-"""A test that when a conversion fails, logs are still produced and contain the expected error message"""
+"""A test that when a conversion fails in the GUI, the log message is output to the alert box"""
 
 l_all_test_specs.append(Spec(name="Failed conversion - invalid conversion",
                              filename=["Fapatite.ins", "nacl.mol"],
@@ -204,28 +253,64 @@ l_all_test_specs.append(Spec(name="Failed conversion - invalid conversion",
                                                           expect_log_exists=None),
                                           CheckException(ex_type=FileConverterHelpException,
                                                          ex_message="is not supported")),
+                             compatible_with_gui=False,
+                             ))
+"""A test that a conversion that fails due an unsupported conversion will properly fail.
+
+Not compatible with the GUI, since the GUI only offers valid conversions.
+"""
+
+l_all_test_specs.append(Spec(name="Blocked conversion - wrong input type",
+                             filename="1NE6.mmcif",
+                             to_format="cif",
+                             conversion_kwargs={"from_format": "pdb", "strict": True},
+                             expect_success=False,
+                             callback=MCB(CheckFileStatus(expect_output_exists=False,
+                                                          expect_log_exists=None),
+                                          CheckException(ex_type=FileConverterInputException,
+                                                         ex_message=("The file extension is not {} or a zip or tar "
+                                                                     "archive extension"))),
+                             compatible_with_library=False,
+                             compatible_with_cla=False,
                              ))
-"""A test that a conversion that fails due an unsupported conversion will properly fail"""
+"""A test that a conversion which is blocked in the GUI"""
 
-l_all_test_specs.append(Spec(name="Failed Conversion - wrong input type",
+l_all_test_specs.append(Spec(name="Failed conversion - wrong input type",
                              filename="1NE6.mmcif",
                              to_format="cif",
-                             conversion_kwargs={"from_format": "pdb"},
+                             conversion_kwargs={"from_format": "pdb", "strict": False},
                              expect_success=False,
                              callback=MCB(CheckFileStatus(expect_output_exists=False,
-                                          expect_log_exists=None),
+                                                          expect_log_exists=None),
                                           CheckException(ex_type=FileConverterAbortException,
-                                                         ex_message="not a valid {} file")),
+                                                         ex_message=("not a valid {} file"))),
                              ))
 """A test that a conversion which fails due to the wrong input file type will properly fail"""
 
-l_all_test_specs.append(Spec(name="Large files",
+l_all_test_specs.append(Spec(name="Large files - Library and CLA",
                              filename=["ch3cl-esp.cub", "benzyne.molden", "periodic_dmol3.outmol",
                                        "fullRhinovirus.pdb"],
                              to_format=["cdjson", "dmol", "mol", "cif"],
                              converter_name=[CONVERTER_OB, CONVERTER_OB, CONVERTER_OB, CONVERTER_C2X],
                              callback=CheckFileStatus(),
+                             compatible_with_gui=False,
+                             ))
+"""Test that the library and CLA can process large files properly"""
+
+l_all_test_specs.append(Spec(name="Large files - GUI",
+                             filename=["ch3cl-esp.cub", "benzyne.molden",
+                                       "periodic_dmol3.outmol", "fullRhinovirus.pdb"],
+                             to_format=["cdjson", "dmol", "mol", "cif"],
+                             converter_name=[CONVERTER_OB, CONVERTER_OB, CONVERTER_OB, CONVERTER_C2X],
+                             expect_success=[False, False, False, True],
+                             callback=[CheckException(ex_type=FileConverterInputException),
+                                       CheckException(ex_type=FileConverterInputException),
+                                       CheckException(ex_type=FileConverterInputException),
+                                       CheckFileStatus()],
+                             compatible_with_library=False,
+                             compatible_with_cla=False,
                              ))
+"""Test that the GUI will refuse to process large files with OB, but will with other converters"""
 
 max_size_callback = MCB(CheckFileStatus(expect_output_exists=False),
                         CheckLogContents("file exceeds maximum size"),
@@ -239,12 +324,16 @@ l_all_test_specs.append(Spec(name="Max size exceeded",
                              expect_success=False,
                              callback=max_size_callback,
                              compatible_with_cla=False,
+                             compatible_with_gui=False,
                              ))
 """A set of test conversion that the maximum size constraint is properly applied. In the first test, the input file
 will be greater than the maximum size, and the test should fail as soon as it checks it. In the second test, the input
 archive is smaller than the maximum size, but the unpacked files in it are greater, so it should fail midway through.
 
 Not compatible with CLA tests, since the CLA doesn't allow the imposition of a maximum size.
+
+Not compatible with GUI tests in current setup of test implementation, which doesn't let us set env vars to control
+things like maximum size on a per-test basis. May be possible to set up in the future though
 """
 
 
@@ -289,11 +378,11 @@ l_all_test_specs.append(Spec(name="Coord gen",
 """A set of tests which checks that coordinate generation options are processed correctly, by matching tests using them
 to expected output files"""
 
-l_library_test_specs = [x for x in l_all_test_specs if x.compatible_with_library]
+l_library_test_specs = [x for x in l_all_test_specs if x.compatible_with_library and not x.skip_all]
 """All test specs which are compatible with being run on the Python library"""
 
-l_cla_test_specs = [x for x in l_all_test_specs if x.compatible_with_cla]
+l_cla_test_specs = [x for x in l_all_test_specs if x.compatible_with_cla and not x.skip_all]
 """All test specs which are compatible with being run on the command-line application"""
 
-l_gui_test_specs = [x for x in l_all_test_specs if x.compatible_with_gui]
+l_gui_test_specs = [x for x in l_all_test_specs if x.compatible_with_gui and not x.skip_all]
 """All test specs which are compatible with being run on the GUI"""