psdi-data-conversion 0.0.39__py3-none-any.whl → 0.1.1__py3-none-any.whl

psdi_data_conversion/app.py

@@ -13,12 +13,14 @@ from collections.abc import Callable
 from datetime import datetime
 from functools import wraps
 from hashlib import md5
+from multiprocessing import Lock
 from subprocess import run
 from traceback import format_exc
 from typing import Any
 
 import werkzeug.serving
 from flask import Flask, Response, abort, cli, render_template, request
+from werkzeug.utils import secure_filename
 
 import psdi_data_conversion
 from psdi_data_conversion import constants as const
@@ -31,24 +33,29 @@ from psdi_data_conversion.main import print_wrap
 # Env var for the SHA of the latest commit
 SHA_EV = "SHA"
 
-# Env var for whether this is running in service mode or locally
-SERVICE_MODE_EV = "SERVICE_MODE"
-
 # Env var for whether this is a production release or development
 PRODUCTION_EV = "PRODUCTION_MODE"
 
+# Env var for whether this is a production release or development
+DEBUG_EV = "DEBUG_MODE"
+
 # Key for the label given to the file uploaded in the web interface
 FILE_TO_UPLOAD_KEY = 'fileToUpload'
 
+# A lock to prevent multiple threads from logging at the same time
+logLock = Lock()
+
 # Create a token by hashing the current date and time.
 dt = str(datetime.now())
 token = md5(dt.encode('utf8')).hexdigest()
 
-# Get the service and production modes from their envvars
-service_mode_ev = os.environ.get(SERVICE_MODE_EV)
+# Get the debug, service and production modes from their envvars
+service_mode_ev = os.environ.get(const.SERVICE_MODE_EV)
 service_mode = (service_mode_ev is not None) and (service_mode_ev.lower() == "true")
 production_mode_ev = os.environ.get(PRODUCTION_EV)
 production_mode = (production_mode_ev is not None) and (production_mode_ev.lower() == "true")
+debug_mode_ev = os.environ.get(DEBUG_EV)
+debug_mode = (debug_mode_ev is not None) and (debug_mode_ev.lower() == "true")
 
 # Get the logging mode and level from their envvars
 ev_log_mode = os.environ.get(const.LOG_MODE_EV)
@@ -86,11 +93,11 @@ if ev_max_file_size_ob is not None:
 else:
     max_file_size_ob = const.DEFAULT_MAX_FILE_SIZE_OB
 
-# Since we're using the development server as the user GUI, we monkey-patch Flask to disable the warnings that would
-# otherwise appear for this so they don't confuse the user
-
 
 def suppress_warning(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Since we're using the development server as the user GUI, we monkey-patch Flask to disable the warnings that
+    would otherwise appear for this so they don't confuse the user
+    """
     @wraps(func)
     def wrapper(*args, **kwargs) -> Any:
         if args and isinstance(args[0], str) and args[0].startswith('WARNING: This is a development server.'):
@@ -105,43 +112,86 @@ cli.show_server_banner = lambda *_: None
 app = Flask(__name__)
 
 
-def get_last_sha() -> str:
+def limit_upload_size():
+    """Impose a limit on the maximum file that can be uploaded before Flask will raise an error"""
+
+    # Determine the largest possible file size that can be uploaded, keeping in mind that 0 indicates unlimited
+    larger_max_file_size = max_file_size
+    if (max_file_size > 0) and (max_file_size_ob > max_file_size):
+        larger_max_file_size = max_file_size_ob
+
+    if larger_max_file_size > 0:
+        app.config['MAX_CONTENT_LENGTH'] = larger_max_file_size
+    else:
+        app.config['MAX_CONTENT_LENGTH'] = None
+
+
+# Set the upload limit based on env vars to start with
+limit_upload_size()
+
+
+def get_tag_and_sha() -> str:
     """Get the SHA of the last commit
     """
 
-    # First check if the SHA is provided through an environmental variable
-    ev_sha = os.environ.get(SHA_EV)
-    if ev_sha:
-        return ev_sha
-
     try:
-        # This bash command calls `git log` to get info on the last commit, uses `head` to trim it to one line, then
-        # uses `gawk` to get just the second word of this line, which is the SHA of this commit
-        cmd = "git log -n 1 | head -n 1 | gawk '{print($2)}'"
+        # This bash command calls `git tag` to get a sorted list of tags, with the most recent at the top, then uses
+        # `head` to trim it to one line
+        cmd = "git tag --sort -version:refname | head -n 1"
 
         out_bytes = run(cmd, shell=True, capture_output=True).stdout
-        out_str = str(out_bytes.decode()).strip()
+        tag = str(out_bytes.decode()).strip()
+
+        # Get the SHA associated with this tag
+        cmd = f"git show {tag}" + " | head -n 1 | gawk '{print($2)}'"
+
+        out_bytes = run(cmd, shell=True, capture_output=True).stdout
+        tag_sha = str(out_bytes.decode()).strip()
 
     except Exception:
-        print("ERROR: Could not determine SHA of most recent commit. Error was:\n" + format_exc(),
+        print("ERROR: Could not determine most recent tag. Error was:\n" + format_exc(),
               file=sys.stderr)
-        out_str = "N/A"
+        tag = ""
+        tag_sha = None
 
-    return out_str
+    # First check if the SHA is provided through an environmental variable
+    ev_sha = os.environ.get(SHA_EV)
+    if ev_sha:
+        sha = ev_sha
+    else:
+        try:
+            # This bash command calls `git log` to get info on the last commit, uses `head` to trim it to one line, then
+            # uses `gawk` to get just the second word of this line, which is the SHA of this commit
+            cmd = "git log -n 1 | head -n 1 | gawk '{print($2)}'"
+
+            out_bytes = run(cmd, shell=True, capture_output=True).stdout
+            sha = str(out_bytes.decode()).strip()
+
+        except Exception:
+            print("ERROR: Could not determine SHA of most recent commit. Error was:\n" + format_exc(),
+                  file=sys.stderr)
+            sha = ""
+
+    # If the SHA of the tag is the same as the current SHA, we indicate this by returning a blank SHA
+    if tag_sha == sha:
+        sha = ""
+
+    return (tag, sha)
 
 
 @app.route('/')
 def website():
     """Return the web page along with the token
     """
-
-    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()}]
-    return render_template("index.htm", data=data)
+    tag, sha = get_tag_and_sha()
+    return render_template("index.htm",
+                           token=token,
+                           max_file_size=max_file_size,
+                           max_file_size_ob=max_file_size_ob,
+                           service_mode=service_mode,
+                           production_mode=production_mode,
+                           tag=tag,
+                           sha=sha)
 
 
 @app.route('/convert/', methods=['POST'])
@@ -153,9 +203,8 @@ def convert():
     # Make sure the upload directory exists
     os.makedirs(const.DEFAULT_UPLOAD_DIR, exist_ok=True)
 
-    # Save the file in the upload directory
     file = request.files[FILE_TO_UPLOAD_KEY]
-    filename = filename = file.filename
+    filename = secure_filename(file.filename)
 
     qualified_filename = os.path.join(const.DEFAULT_UPLOAD_DIR, filename)
     file.save(qualified_filename)
@@ -248,7 +297,10 @@ def feedback():
             if key in report:
                 entry[key] = str(report[key])
 
-        log_utility.append_to_log_file("feedback", entry)
+        # Write data in JSON format and send to stdout
+        logLock.acquire()
+        sys.stdout.write(f"{json.dumps(entry) + '\n'}")
+        logLock.release()
 
         return Response(status=201)
 
@@ -318,7 +370,7 @@ def start_app():
     """
 
     os.chdir(os.path.join(psdi_data_conversion.__path__[0], ".."))
-    app.run()
+    app.run(debug=debug_mode)
 
 
 def main():
@@ -343,7 +395,11 @@ def main():
                         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")
+                        help="If set, will expose development elements, such as the SHA of the latest commit")
+
+    parser.add_argument("--debug", action="store_true",
+                        help="If set, will run the Flask server in debug mode, which will cause it to automatically "
+                        "reload if code changes and show an interactive debugger in the case of errors")
 
     parser.add_argument("--log-mode", type=str, default=const.LOG_FULL,
                         help="How logs should be stored. Allowed values are: \n"
@@ -371,6 +427,9 @@ def main():
         global service_mode
         service_mode = args.service_mode
 
+        global debug_mode
+        debug_mode = args.debug
+
         global production_mode
         production_mode = not args.dev_mode
 
@@ -380,6 +439,9 @@ def main():
         global log_level
         log_level = args.log_level
 
+    # Set the upload limit based on provided arguments now
+    limit_upload_size()
+
     print_wrap("Starting the PSDI Data Conversion GUI. This GUI is run as a webpage, which you can open by "
                "right-clicking the link below to open it in your default browser, or by copy-and-pasting it into your "
                "browser of choice.")

psdi_data_conversion/constants.py

@@ -41,6 +41,7 @@ LOG_MODE_EV = "LOG_MODE"
 LOG_LEVEL_EV = "LOG_LEVEL"
 MAX_FILESIZE_EV = "MAX_FILESIZE"
 MAX_FILESIZE_OB_EV = "MAX_FILESIZE_OB"
+SERVICE_MODE_EV = "SERVICE_MODE"
 
 # Files and Folders
 # -----------------

psdi_data_conversion/converter.py

@@ -5,11 +5,16 @@ Created 2024-12-10 by Bryan Gillis.
 Class and functions to perform file conversion
 """
 
+from dataclasses import dataclass, field
+import json
 import glob
 import importlib
 import os
 import sys
 import traceback
+from typing import Any, Callable, NamedTuple
+from multiprocessing import Lock
+from psdi_data_conversion import log_utility
 from collections.abc import Callable
 from dataclasses import dataclass, field
 from tempfile import TemporaryDirectory
@@ -20,6 +25,10 @@ from psdi_data_conversion.converters import base
 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)
+from psdi_data_conversion.utils import regularize_name
+
+# A lock to prevent multiple threads from logging at the same time
+logLock = Lock()
 
 # Find all modules for specific converters
 l_converter_modules = glob.glob(os.path.dirname(base.__file__) + "/*.py")
@@ -49,7 +58,8 @@ try:
 
         converter_class = module.converter
 
-        name = converter_class.name
+        # To make querying case/space-insensitive, we store all names in lowercase with spaces stripped
+        name = converter_class.name.lower().replace(" ", "")
 
         return NameAndClass(name, converter_class)
 
@@ -91,6 +101,66 @@ except Exception:
     D_CONVERTER_ARGS = {}
 
 
+def get_supported_converter_class(name: str):
+    """Get the appropriate converter class matching the provided name from the dict of supported converters
+
+    Parameters
+    ----------
+    name : str
+        Converter name (case- and space-insensitive)
+
+    Returns
+    -------
+    type[base.FileConverter]
+    """
+    return D_SUPPORTED_CONVERTERS[regularize_name(name)]
+
+
+def get_registered_converter_class(name: str):
+    """Get the appropriate converter class matching the provided name from the dict of supported converters
+
+    Parameters
+    ----------
+    name : str
+        Converter name (case- and space-insensitive)
+
+    Returns
+    -------
+    type[base.FileConverter]
+    """
+    return D_REGISTERED_CONVERTERS[regularize_name(name)]
+
+
+def converter_is_supported(name: str):
+    """Checks if a converter is supported in principle by this project
+
+    Parameters
+    ----------
+    name : str
+        Converter name (case- and space-insensitive)
+
+    Returns
+    -------
+    bool
+    """
+    return regularize_name(name) in L_SUPPORTED_CONVERTERS
+
+
+def converter_is_registered(name: str):
+    """Checks if a converter is registered (usable)
+
+    Parameters
+    ----------
+    name : str
+        Converter name (case- and space-insensitive)
+
+    Returns
+    -------
+    bool
+    """
+    return regularize_name(name) in L_REGISTERED_CONVERTERS
+
+
 def get_converter(*args, name=const.CONVERTER_DEFAULT, **converter_kwargs) -> base.FileConverter:
     """Get a FileConverter of the proper subclass for the requested converter type
 
@@ -129,7 +199,7 @@ def get_converter(*args, name=const.CONVERTER_DEFAULT, **converter_kwargs) -> ba
         If provided, all logging will go to a single file or stream. Otherwise, logs will be split up among multiple
         files for server-style logging.
     log_mode : str
-        How logs should be stores. Allowed values are:
+        How logs should be stored. Allowed values are:
         - 'full' - Multi-file logging, only recommended when running as a public web app
         - 'simple' - Logs saved to one file
         - 'stdout' - Output logs and errors only to stdout
@@ -155,10 +225,11 @@ def get_converter(*args, name=const.CONVERTER_DEFAULT, **converter_kwargs) -> ba
     FileConverterInputException
         If the converter isn't recognized or there's some other issue with the input
     """
+    name = regularize_name(name)
     if name not in L_REGISTERED_CONVERTERS:
         raise base.FileConverterInputException(const.ERR_CONVERTER_NOT_RECOGNISED.format(name) +
                                                f"{L_REGISTERED_CONVERTERS}")
-    converter_class = D_REGISTERED_CONVERTERS[name]
+    converter_class = get_registered_converter_class(name)
 
     return converter_class(*args, **converter_kwargs)
 
@@ -302,7 +373,7 @@ def run_converter(filename: str,
         If provided, all logging will go to a single file or stream. Otherwise, logs will be split up among multiple
         files for server-style logging.
     log_mode : str
-        How logs should be stores. Allowed values are:
+        How logs should be stored. Allowed values are:
         - 'full' - Multi-file logging, only recommended when running as a public web app
         - 'simple' - Logs saved to one file
         - 'stdout' - Output logs and errors only to stdout
@@ -355,14 +426,14 @@ def run_converter(filename: str,
         if from_format is not None:
             check_from_format(filename, from_format, strict=strict)
         l_run_output.append(get_converter(filename,
-                                          to_format,
-                                          *args,
-                                          from_format=from_format,
-                                          download_dir=download_dir,
-                                          max_file_size=max_file_size,
-                                          log_file=log_file,
-                                          log_mode=log_mode,
-                                          **converter_kwargs).run())
+                            to_format,
+                            *args,
+                            from_format=from_format,
+                            download_dir=download_dir,
+                            max_file_size=max_file_size,
+                            log_file=log_file,
+                            log_mode=log_mode,
+                            **converter_kwargs).run())
 
     elif not is_supported_archive(filename):
         raise base.FileConverterInputException(f"{filename} is an unsupported archive type. Supported types are: "
@@ -473,4 +544,61 @@ def run_converter(filename: str,
                 exception_class = base.FileConverterAbortException
             raise exception_class(status_code, msg)
 
+    # Log conversion information if in service mode
+    service_mode_ev = os.environ.get(const.SERVICE_MODE_EV)
+    service_mode = (service_mode_ev is not None) and (service_mode_ev.lower() == "true")
+    if service_mode:
+        try:
+            l_index = filename.rfind('/') + 1
+            r_index = len(filename)
+            in_filename = filename[l_index:r_index]
+
+            l_index = run_output.output_filename.rfind('/') + 1
+            r_index = len(run_output.output_filename)
+
+            input_size = set_size_units(run_output.in_size)
+            output_size = set_size_units(run_output.out_size)
+
+            if status_code:
+                outcome = "failed"
+                fail_reason = l_error_lines
+            else:
+                outcome = "succeeded"
+                fail_reason = ""
+
+            entry = {
+                "datetime": log_utility.get_date_time(),
+                "input_format": converter_kwargs['data']['from_full'],
+                "output_format": converter_kwargs['data']['to_full'],
+                "input_filename": in_filename,
+                "output_filename": run_output.output_filename[l_index:r_index],
+                "input_size": input_size,
+                "output_size": output_size }
+
+            for key in [ "converter", "coordinates", "coordOption", "from_flags",
+                "to_flags", "from_arg_flags", "to_arg_flags" ]:
+                if key in converter_kwargs['data'] and converter_kwargs['data'][key] != "" and not \
+                    ((key == "coordinates" or key == "coordOption") and converter_kwargs['data']['coordinates'] == "neither") :
+                    entry[key] = converter_kwargs['data'][key]
+
+            entry["outcome"] = outcome
+
+            if fail_reason != "":
+                entry["fail_reason"] = fail_reason
+
+            logLock.acquire()
+            sys.__stdout__.write(f"{json.dumps(entry) + '\n'}")
+            logLock.release()
+        except Exception:
+            sys.__stdout__.write({"datetime": log_utility.get_date_time(),
+                                  "logging_error": "An error occurred during logging of conversion information."})
+
     return run_output
+
+def set_size_units(size):
+    if size >= 1024:
+        return str('%.3f' % (size / 1024)) + ' kB'
+    elif size >= const.MEGABYTE:
+        return str(size / const.MEGABYTE) + ' MB'
+    else:
+        return str(size) + ' B'

psdi_data_conversion/database.py

@@ -15,8 +15,9 @@ from logging import getLogger
 from typing import Any, Literal, overload
 
 from psdi_data_conversion import constants as const
-from psdi_data_conversion.converter import D_REGISTERED_CONVERTERS, D_SUPPORTED_CONVERTERS
+from psdi_data_conversion.converter import D_SUPPORTED_CONVERTERS, get_registered_converter_class
 from psdi_data_conversion.converters.base import FileConverterException
+from psdi_data_conversion.utils import regularize_name
 
 # Keys for top-level and general items in the database
 DB_FORMATS_KEY = "formats"
@@ -117,14 +118,14 @@ class ConverterInfo:
         Parameters
         ----------
         name : str
-            The name of the converter
+            The regularized name of the converter
         parent : DataConversionDatabase
             The database which this belongs to
         d_data : dict[str, Any]
             The loaded database dict
         """
 
-        self.name = name
+        self.name = regularize_name(name)
         self.parent = parent
 
         # Get info about the converter from the database
@@ -134,7 +135,7 @@ class ConverterInfo:
 
         # Get necessary info about the converter from the class
         try:
-            self._key_prefix = D_REGISTERED_CONVERTERS[name].database_key_prefix
+            self._key_prefix = get_registered_converter_class(name).database_key_prefix
         except KeyError:
             # We'll get a KeyError for converters in the database that don't yet have their own class, which we can
             # safely ignore
@@ -529,6 +530,10 @@ class ConversionQualityInfo:
     input and output file formats and a note on the implications
     """
 
+    def __post_init__(self):
+        """Regularize the converter name"""
+        self.converter_name = regularize_name(self.converter_name)
+
 
 class ConversionsTable:
     """Class providing information on available file format conversions.
@@ -623,7 +628,7 @@ class ConversionsTable:
 
         # Check if this converter deals with ambiguous formats, so we know if we need to be strict about getting format
         # info
-        if D_REGISTERED_CONVERTERS[converter_name].supports_ambiguous_extensions:
+        if get_registered_converter_class(converter_name).supports_ambiguous_extensions:
             which_format = None
         else:
             which_format = 0
@@ -805,7 +810,7 @@ class DataConversionDatabase:
         if self._d_converter_info is None:
             self._d_converter_info: dict[str, ConverterInfo] = {}
             for d_single_converter_info in self.converters:
-                name: str = d_single_converter_info[DB_NAME_KEY]
+                name: str = regularize_name(d_single_converter_info[DB_NAME_KEY])
                 if name in self._d_converter_info:
                     logger.warning(f"Converter '{name}' appears more than once in the database. Only the first instance"
                                    " will be used.")
@@ -1095,7 +1100,7 @@ def get_converter_info(name: str) -> ConverterInfo:
     ConverterInfo
     """
 
-    return get_database().d_converter_info[name]
+    return get_database().d_converter_info[regularize_name(name)]
 
 
 @overload
@@ -1155,7 +1160,7 @@ def get_conversion_quality(converter_name: str,
         `ConversionQualityInfo` object with info on the conversion
     """
 
-    return get_database().conversions_table.get_conversion_quality(converter_name=converter_name,
+    return get_database().conversions_table.get_conversion_quality(converter_name=regularize_name(converter_name),
                                                                    in_format=in_format,
                                                                    out_format=out_format)
 
@@ -1210,6 +1215,9 @@ def disambiguate_formats(converter_name: str,
         If more than one format combination is possible for this conversion, or no conversion is possible
     """
 
+    # Regularize the converter name so we don't worry about case/spacing mismatches
+    converter_name = regularize_name(converter_name)
+
     # Get all possible conversions, and see if we only have one for this converter
     l_possible_conversions = [x for x in get_possible_conversions(in_format, out_format)
                               if x[0] == converter_name]
@@ -1243,7 +1251,7 @@ def get_possible_formats(converter_name: str) -> tuple[list[FormatInfo], list[Fo
     tuple[list[FormatInfo], list[FormatInfo]]
         A tuple of a list of the supported input formats and a list of the supported output formats
     """
-    return get_database().conversions_table.get_possible_formats(converter_name=converter_name)
+    return get_database().conversions_table.get_possible_formats(converter_name=regularize_name(converter_name))
 
 
 def _find_arg(tl_args: tuple[list[FlagInfo], list[OptionInfo]],

psdi_data_conversion/main.py

@@ -16,8 +16,10 @@ from itertools import product
 
 from psdi_data_conversion import constants as const
 from psdi_data_conversion.constants import CL_SCRIPT_NAME, CONVERTER_DEFAULT, TERM_WIDTH
-from psdi_data_conversion.converter import (D_CONVERTER_ARGS, D_SUPPORTED_CONVERTERS, L_REGISTERED_CONVERTERS,
-                                            L_SUPPORTED_CONVERTERS, run_converter)
+from psdi_data_conversion.converter import (D_CONVERTER_ARGS, L_REGISTERED_CONVERTERS, L_SUPPORTED_CONVERTERS,
+                                            converter_is_registered, converter_is_supported,
+                                            get_registered_converter_class, get_supported_converter_class,
+                                            run_converter)
 from psdi_data_conversion.converters.base import (FileConverterAbortException, FileConverterException,
                                                   FileConverterInputException)
 from psdi_data_conversion.database import (FormatInfo, get_conversion_quality, get_converter_info, get_format_info,
@@ -25,6 +27,7 @@ from psdi_data_conversion.database import (FormatInfo, get_conversion_quality, g
                                            get_possible_formats)
 from psdi_data_conversion.file_io import split_archive_ext
 from psdi_data_conversion.log_utility import get_log_level_from_str
+from psdi_data_conversion.utils import regularize_name
 
 
 def print_wrap(s: str, newline=False, err=False, **kwargs):
@@ -58,9 +61,9 @@ class ConvertArgs:
         self._output_dir: str | None = args.out
         converter_name = getattr(args, "with")
         if isinstance(converter_name, str):
-            self.name = converter_name
+            self.name = regularize_name(converter_name)
         elif converter_name:
-            self.name: str = " ".join(converter_name)
+            self.name = regularize_name(" ".join(converter_name))
         else:
             self.name = None
         self.delete_input = args.delete_input
@@ -109,14 +112,14 @@ class ConvertArgs:
 
             # Get the converter name from the arguments if it wasn't provided by -w/--with
             if not self.name:
-                self.name = " ".join(self.l_args)
+                self.name = regularize_name(" ".join(self.l_args))
 
             # For this operation, any other arguments can be ignored
             return
 
         # If not listing and a converter name wasn't supplied, use the default converter
         if not self.name:
-            self.name = CONVERTER_DEFAULT
+            self.name = regularize_name(CONVERTER_DEFAULT)
 
         # Quiet mode is equivalent to logging mode == LOGGING_NONE, so normalize them if either is set
         if self.quiet:
@@ -147,13 +150,14 @@ class ConvertArgs:
             os.makedirs(self._output_dir, exist_ok=True)
 
         # Check the converter is recognized
-        if self.name not in L_SUPPORTED_CONVERTERS:
+        if not converter_is_supported(self.name):
             msg = textwrap.fill(f"ERROR: Converter '{self.name}' not recognised", width=TERM_WIDTH)
             msg += f"\n\n{get_supported_converters()}"
             raise FileConverterInputException(msg, help=True, msg_preformatted=True)
-        elif self.name not in L_REGISTERED_CONVERTERS:
-            msg = textwrap.fill(f"ERROR: Converter '{self.name}' is not registered. It may be possible to register "
-                                "it by installing an appropriate binary for your platform.", width=TERM_WIDTH)
+        elif not converter_is_registered(self.name):
+            converter_name = get_supported_converter_class(self.name).name
+            msg = textwrap.fill(f"ERROR: Converter '{converter_name}' is not registered. It may be possible to "
+                                "register it by installing an appropriate binary for your platform.", width=TERM_WIDTH)
             msg += f"\n\n{get_supported_converters()}"
             raise FileConverterInputException(msg, help=True, msg_preformatted=True)
 
@@ -349,9 +353,10 @@ def detail_converter_use(args: ConvertArgs):
     """
 
     converter_info = get_converter_info(args.name)
-    converter_class = D_SUPPORTED_CONVERTERS[args.name]
+    converter_class = get_supported_converter_class(args.name)
+    converter_name = converter_class.name
 
-    print_wrap(f"{converter_info.name}: {converter_info.description} ({converter_info.url})", break_long_words=False,
+    print_wrap(f"{converter_name}: {converter_info.description} ({converter_info.url})", break_long_words=False,
                break_on_hyphens=False, newline=True)
 
     if converter_class.info:
@@ -362,10 +367,10 @@ def detail_converter_use(args: ConvertArgs):
     if args.from_format is not None and args.to_format is not None:
         qual = get_conversion_quality(args.name, args.from_format, args.to_format)
         if qual is None:
-            print_wrap(f"Conversion from '{args.from_format}' to '{args.to_format}' with {args.name} is not "
+            print_wrap(f"Conversion from '{args.from_format}' to '{args.to_format}' with {converter_name} is not "
                        "supported.", newline=True)
         else:
-            print_wrap(f"Conversion from '{args.from_format}' to '{args.to_format}' with {args.name} is "
+            print_wrap(f"Conversion from '{args.from_format}' to '{args.to_format}' with {converter_name} is "
                        f"possible with {qual.qual_str} conversion quality", newline=True)
             # If there are any potential issues with the conversion, print them out
             if qual.details:
@@ -385,7 +390,7 @@ def detail_converter_use(args: ConvertArgs):
                 optional_not: str = ""
             else:
                 optional_not: str = "not "
-            print_wrap(f"Conversion {to_or_from} {format_name} is {optional_not}supported by {args.name}.\n")
+            print_wrap(f"Conversion {to_or_from} {format_name} is {optional_not}supported by {converter_name}.\n")
 
         # List all possible formats, and which can be used for input and which for output
         s_all_formats: set[FormatInfo] = set(l_input_formats)
@@ -393,7 +398,7 @@ def detail_converter_use(args: ConvertArgs):
         l_all_formats: list[FormatInfo] = list(s_all_formats)
         l_all_formats.sort(key=lambda x: x.disambiguated_name.lower())
 
-        print_wrap(f"File formats supported by {args.name}:", newline=True)
+        print_wrap(f"File formats supported by {converter_name}:", newline=True)
         max_format_length = max([len(x.disambiguated_name) for x in l_all_formats])
         print(" "*(max_format_length+4) + "   INPUT  OUTPUT")
         print(" "*(max_format_length+4) + "   -----  ------")
@@ -472,13 +477,13 @@ def detail_converter_use(args: ConvertArgs):
     # Now at the end, bring up input/output-format-specific flags and options
     if mention_input_format and mention_output_format:
         print_wrap("For details on input/output flags and options allowed for specific formats, call:\n"
-                   f"{CL_SCRIPT_NAME} -l {args.name} -f <input_format> -t <output_format>")
+                   f"{CL_SCRIPT_NAME} -l {converter_name} -f <input_format> -t <output_format>")
     elif mention_input_format:
         print_wrap("For details on input flags and options allowed for a specific format, call:\n"
-                   f"{CL_SCRIPT_NAME} -l {args.name} -f <input_format> [-t <output_format>]")
+                   f"{CL_SCRIPT_NAME} -l {converter_name} -f <input_format> [-t <output_format>]")
     elif mention_output_format:
         print_wrap("For details on output flags and options allowed for a specific format, call:\n"
-                   f"{CL_SCRIPT_NAME} -l {args.name} -t <output_format> [-f <input_format>]")
+                   f"{CL_SCRIPT_NAME} -l {converter_name} -t <output_format> [-f <input_format>]")
 
 
 def list_supported_formats(err=False):
@@ -600,9 +605,11 @@ def detail_formats_and_possible_converters(from_format: str, to_format: str):
         l_conversions_matching_formats = [x for x in l_possible_conversions
                                           if x[1] == possible_from_format and x[2] == possible_to_format]
 
-        l_possible_registered_converters = [x[0] for x in l_conversions_matching_formats
+        l_possible_registered_converters = [get_registered_converter_class(x[0]).name
+                                            for x in l_conversions_matching_formats
                                             if x[0] in L_REGISTERED_CONVERTERS]
-        l_possible_unregistered_converters = [x[0] for x in l_conversions_matching_formats
+        l_possible_unregistered_converters = [get_supported_converter_class(x[0]).name
+                                              for x in l_conversions_matching_formats
                                               if x[0] in L_SUPPORTED_CONVERTERS and x[0] not in L_REGISTERED_CONVERTERS]
 
         print()
@@ -640,7 +647,7 @@ def get_supported_converters():
     l_converters: list[str] = []
     any_not_registered = False
     for converter_name in L_SUPPORTED_CONVERTERS:
-        converter_text = converter_name
+        converter_text = get_supported_converter_class(converter_name).name
         if converter_name not in L_REGISTERED_CONVERTERS:
             converter_text += f" {MSG_NOT_REGISTERED}"
             any_not_registered = True

psdi_data_conversion/static/content/index-versions/psdi-common-footer.html

@@ -48,7 +48,7 @@
         <hr>
       </div>
       <ul class="footer__col footer__items clean-list">
-        <li><a href="https://psdistg.wpengine.com/">PSDI Home</a></li>
+        <li><a href="https://psdi.ac.uk/">PSDI Home</a></li>
         <li><a href="mailto:support@psdi.ac.uk">Contact Us</a></li>
         <li><a href="https://www.psdi.ac.uk/privacy/">Privacy</a></li>
         <li><a href="https://www.psdi.ac.uk/terms-and-conditions/">Terms and Conditions</a></li>

psdi_data_conversion/static/content/index-versions/psdi-common-header.html

@@ -4,7 +4,7 @@
 <div class="max-width-box navbar">
   <div class="header-left">
     <div class="navbar__brand">
-      <a class="navbar__logo" href="https://psdistg.wpengine.com/">
+      <a class="navbar__logo" href="https://psdi.ac.uk/">
         <img src="static/img/psdi-logo-darktext.png" alt="PSDI logo"
           class="lm-only">
         <img src="static/img/psdi-logo-lighttext.png" alt="PSDI logo"

psdi_data_conversion/static/content/psdi-common-footer.html

@@ -48,7 +48,7 @@
         <hr>
       </div>
       <ul class="footer__col footer__items clean-list">
-        <li><a href="https://psdistg.wpengine.com/">PSDI Home</a></li>
+        <li><a href="https://psdi.ac.uk/">PSDI Home</a></li>
         <li><a href="mailto:support@psdi.ac.uk">Contact Us</a></li>
         <li><a href="https://www.psdi.ac.uk/privacy/">Privacy</a></li>
         <li><a href="https://www.psdi.ac.uk/terms-and-conditions/">Terms and Conditions</a></li>

psdi_data_conversion/static/content/psdi-common-header.html

@@ -4,7 +4,7 @@
 <div class="max-width-box navbar">
   <div class="header-left">
     <div class="navbar__brand">
-      <a class="navbar__logo" href="https://psdistg.wpengine.com/">
+      <a class="navbar__logo" href="https://psdi.ac.uk/">
         <img src="../img/psdi-logo-darktext.png" alt="PSDI logo"
           class="lm-only">
         <img src="../img/psdi-logo-lighttext.png" alt="PSDI logo"

psdi_data_conversion/templates/index.htm

@@ -20,13 +20,12 @@
     crossorigin="anonymous"></script>
   <script src="https://cdn.jsdelivr.net/jquery.dirtyforms/2.0.0/jquery.dirtyforms.min.js"></script>
 
-  {% for item in data %}
   <script>
-    const token = "{{item.token}}";
-    const max_file_size = "{{item.max_file_size}}";
-    const max_file_size_ob = "{{item.max_file_size_ob}}";
-    const service_mode = "{{item.service_mode}}";
-    const production_mode = "{{item.production_mode}}";
+    const token = "{{token}}";
+    const max_file_size = "{{max_file_size}}";
+    const max_file_size_ob = "{{max_file_size_ob}}";
+    const service_mode = "{{service_mode}}";
+    const production_mode = "{{production_mode}}";
     document.documentElement.setAttribute("service-mode", service_mode);
     document.documentElement.setAttribute("production-mode", production_mode);
   </script>
@@ -121,11 +120,11 @@
       <div class="medGap"></div>
     </div>
   </form>
-
+  {% if tag %}
   <div class="secondary prod-only">
-    <div class="max-width-box">SHA: {{item.sha}}</div>
+    <div class="max-width-box">PSDI Data Conversion {{ tag }} {% if sha %} (SHA: {{ sha }}) {% endif %}</div>
   </div>
-  {% endfor %}
+  {% endif %}
   <script src="{{url_for('static', filename='/javascript/format.js')}}" type="module" language="JavaScript"></script>
 
   <footer class="footer" id="psdi-footer"></footer>

psdi_data_conversion/testing/conversion_test_specs.py

@@ -30,7 +30,9 @@ l_all_test_specs.append(Spec(name="Standard Single Test",
                                           CheckLogContentsSuccess(),
                                           MatchOutputFile("standard_test.inchi")),
                              ))
+"""A quick single test, functioning mostly as a smoke test for things going right in the simplest case"""
 
+simple_success_callback = MCB(CheckFileStatus(), CheckLogContentsSuccess())
 l_all_test_specs.append(Spec(name="Standard Multiple Tests",
                              filename=["1NE6.mmcif",
                                        "hemoglobin.pdb", "aceticacid.mol", "nacl.cif",
@@ -52,8 +54,7 @@ l_all_test_specs.append(Spec(name="Standard Multiple Tests",
                                              CONVERTER_ATO, CONVERTER_ATO, CONVERTER_ATO,
                                              CONVERTER_C2X, CONVERTER_C2X, CONVERTER_C2X,
                                              CONVERTER_OB],
-                             callback=MCB(CheckFileStatus(),
-                                          CheckLogContentsSuccess()),
+                             callback=simple_success_callback,
                              ))
 """A basic set of test conversions which we expect to succeed without issue, running conversions with each of the
 Open Babel, Atomsk, and c2x converters"""
@@ -61,14 +62,21 @@ Open Babel, Atomsk, and c2x converters"""
 l_all_test_specs.append(Spec(name="c2x Formats Tests",
                              to_format=["res", "abi", "POSCAR", "cml"],
                              converter_name=CONVERTER_C2X,
-                             callback=MCB(CheckFileStatus(),
-                                          CheckLogContentsSuccess()),
+                             callback=simple_success_callback,
                              compatible_with_gui=False,
                              ))
 """Test converting with c2x to a few different formats which require special input. This test isn't run in the GUI
 solely to save on resources, since there are unlikely to be an GUI-specific issues raised by this test that aren't
 caught in others."""
 
+l_all_test_specs.append(Spec(name="Converter Name Sensitivity Tests",
+                             converter_name=["open babel", "oPeNbaBEL", "C2X", "atomsk"],
+                             to_format="xyz-0",
+                             callback=simple_success_callback,
+                             compatible_with_gui=False,
+                             ))
+"""Tests that converters can be specified case- and space-insensitively in the library and CLI"""
+
 archive_callback = MCB(CheckFileStatus(),
                        CheckArchiveContents(l_filename_bases=["caffeine-no-flags",
                                                               "caffeine-ia",

psdi_data_conversion/utils.py

@@ -0,0 +1,21 @@
+"""
+# utils.py
+
+Miscellaneous utility functions used by this project
+"""
+
+
+def regularize_name(name: str):
+    """Regularizes a name for comparisons, making it lowercase and stripping spaces
+
+    Parameters
+    ----------
+    name : str
+        The name, e.g. "Open Babel"
+
+    Returns
+    -------
+    str
+        The regularized name, e.g. "openbabel"
+    """
+    return name.lower().replace(" ", "")

{psdi_data_conversion-0.0.39.dist-info → psdi_data_conversion-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psdi_data_conversion
-Version: 0.0.39
+Version: 0.1.1
 Summary: Chemistry file format conversion service, provided by PSDI
 Project-URL: Homepage, https://data-conversion.psdi.ac.uk/
 Project-URL: Documentation, https://psdi-uk.github.io/psdi-data-conversion/
@@ -243,7 +243,7 @@ Description-Content-Type: text/markdown
 
 # PSDI Data Conversion
 
-Version: Pre-release 2024-04-14
+Release date: 2024-04-29
 
 This is the repository for the PSDI PF2 Chemistry File Format Conversion project. The goal of this project is to provide utilities to assist in converting files between the many different file formats used in chemistry, providing information on what converters are available for a given conversion and the expected quality of it, and providing multiple interfaces to perform these conversions. These interfaces are:
 

{psdi_data_conversion-0.0.39.dist-info → psdi_data_conversion-0.1.1.dist-info}/RECORD

@@ -1,13 +1,14 @@
 psdi_data_conversion/__init__.py,sha256=urMsTqsTHTch1q4rMT9dgGnrvdPFMP9B8r-6Kr8H5sE,404
-psdi_data_conversion/app.py,sha256=A1TUVYuHUJKbtBXC0MbCDwyNcZgCYLDWyt_2lPLETK0,14212
-psdi_data_conversion/constants.py,sha256=JWYC2gXsEi6bBl_NdEBh5nLZ7qX2LZZV_DutfEHJ8qo,7390
-psdi_data_conversion/converter.py,sha256=A9u_xnzQ_OFp_rttttBNwZNA4d56Fdbm9FpjgyCroUA,23211
-psdi_data_conversion/database.py,sha256=tgqUxW75eaWiEsiHNI7pUfMTIKmB23zrprSZ3ZDpO3Y,55967
+psdi_data_conversion/app.py,sha256=jU0cK3yduKQkDECf1UGJCPpBF57bUitM_YHH0vsoS4A,16745
+psdi_data_conversion/constants.py,sha256=Hq2OVbcSkcv6T87-YJlo1PVlr9ILlB4H3E9JYjzvCF4,7423
+psdi_data_conversion/converter.py,sha256=Y77mqH2OKxf2YelphWDl82AKoRa-APle-l3e8wG_WZA,27315
+psdi_data_conversion/database.py,sha256=XzKvtT-cFmKLWLo5OBB5CV_rGHuqEEuENNyZnbS39qE,56419
 psdi_data_conversion/dist.py,sha256=LOcKEP7H7JA9teX1m-5awuBi69gmdhtUit7yxtCTOZ8,2293
 psdi_data_conversion/file_io.py,sha256=LvdPmnYL_7Xlcr-7LJjUbbky4gKiqTTvPRzdbtvQaJo,8794
 psdi_data_conversion/log_utility.py,sha256=CHAq-JvBnTKaE0SHK5hM5j2dTbfSli4iUc3hsf6dBhc,8789
-psdi_data_conversion/main.py,sha256=NaV5Pqe-8qYn7ybgok3t6RuRK1H_9ip68UWpV7DRgO0,41773
+psdi_data_conversion/main.py,sha256=9Gu3CxbUfMuDxyNBx_-kQwWB4eOTWRHGmxCsVnpdbvs,42421
 psdi_data_conversion/security.py,sha256=wjdrMre29TpkF2NqrsXJ5sschSAnDzqLYTLUcNR21Qw,902
+psdi_data_conversion/utils.py,sha256=iTjNfrD4n_hU9h20ldYrX2Bmp5KhCBIeMSUMLtPZ_8k,402
 psdi_data_conversion/bin/LICENSE_ATOMSK,sha256=-Ay6SFTAf9x-OaRAiOgMNoutfUMLHx5jQQA1HqZ6p7I,34886
 psdi_data_conversion/bin/LICENSE_C2X,sha256=-Ay6SFTAf9x-OaRAiOgMNoutfUMLHx5jQQA1HqZ6p7I,34886
 psdi_data_conversion/bin/linux/atomsk,sha256=GDsG1MlEvmk_XPspadzEzuil6N775iewDvNZS6rWJWk,34104032
@@ -29,12 +30,12 @@ psdi_data_conversion/static/content/documentation.htm,sha256=1GiEjlDCP0kJ3CKkx3l
 psdi_data_conversion/static/content/download.htm,sha256=DQKWEuq_Bjv2TyV6DnPXnHrSOBvGYRHOU-m6YOwfsh4,4727
 psdi_data_conversion/static/content/feedback.htm,sha256=fZrhn4Egs9g6ygqPzV6ZG9ndYK02VdALNVNXRsZ716k,1788
 psdi_data_conversion/static/content/header-links.html,sha256=7B2bHa7dLfSZ4hPMvVJ3kR0niVAOO3FtHJo0K6m1oP4,693
-psdi_data_conversion/static/content/psdi-common-footer.html,sha256=Qo6ecItnjqngIu1Kyg8YOptqjraMFxyJTYu3wiW5Wuw,4080
-psdi_data_conversion/static/content/psdi-common-header.html,sha256=vRAgLGKE_RhXgBUQnarxnpkGl9j2Qeedqqo3VNDVGdk,1825
+psdi_data_conversion/static/content/psdi-common-footer.html,sha256=3_KqTtwtkvCvi52LcRrN7oVfMfFdHqrHc39gMrYzGxg,4070
+psdi_data_conversion/static/content/psdi-common-header.html,sha256=2upXPOZ-EM6Bv7ltPJnynPBjYz4Z27sNl4LuUaVdVjM,1815
 psdi_data_conversion/static/content/report.htm,sha256=CRwlF7a7QvAjHsajuehWOtLxbo-JAjqrS_Q-I4BWxzs,4549
 psdi_data_conversion/static/content/index-versions/header-links.html,sha256=WN9oZL7hLtH_yv5PvX3Ky7_YGrNvQL_RQ5eU8DB50Rg,764
-psdi_data_conversion/static/content/index-versions/psdi-common-footer.html,sha256=nFZtEObp-X73p95oTOAvqzoPwjsEJD5dKUDhUPDCcj4,4136
-psdi_data_conversion/static/content/index-versions/psdi-common-header.html,sha256=IXmvdlArY-60b7HgvKjcNF3eSmEmTImX7Hdasswyi5s,1907
+psdi_data_conversion/static/content/index-versions/psdi-common-footer.html,sha256=APBMI9c5-4fNV-CCYEs9ySgAahc7u1w-0e3EjM1MiD8,4126
+psdi_data_conversion/static/content/index-versions/psdi-common-header.html,sha256=w6Q_uu0W4MdioVoh6w0Cy4m2ACr7xAnampx1TfPvT9M,1897
 psdi_data_conversion/static/data/data.json,sha256=1nljosxtwbLRfIIIa6-GHJnhvzhB759oEGvVQ18QP_4,3647095
 psdi_data_conversion/static/img/colormode-toggle-dm.svg,sha256=Q85ODwU67chZ77lyT9gITtnmqzJEycFmz35dJuqaPXE,502
 psdi_data_conversion/static/img/colormode-toggle-lm.svg,sha256=sIKXsNmLIXU4fSuuqrN0r-J4Hd3NIqoiXNT3mdq5-Fo,1155
@@ -73,15 +74,15 @@ psdi_data_conversion/static/javascript/psdi-common.js,sha256=I0QqGQ7l_rA4KEfenQT
 psdi_data_conversion/static/javascript/report.js,sha256=BHH5UOhXJtB6J_xk_y6woquNKt5W9hCrQapxKtGG1eA,12470
 psdi_data_conversion/static/styles/format.css,sha256=PaQkUVxQfXI9nbJ-7YsN1tNIcLXfwXk8wJC-zht8nRA,3269
 psdi_data_conversion/static/styles/psdi-common.css,sha256=09VY-lldoZCrohuqPKnd9fvDget5g9ybi6uh13pYeY0,17249
-psdi_data_conversion/templates/index.htm,sha256=wuHECSzTwVwmaGg55RnYunsaSFCYBmxf6_P4OygTNEQ,6824
+psdi_data_conversion/templates/index.htm,sha256=Y1KlrBirqDPyleVl_Edgbm_jYMBYGnOEMdCzmDBJi3o,6842
 psdi_data_conversion/testing/__init__.py,sha256=Xku7drtLTYLLPsd403eC0LIEa_iohVifyeyAITy2w7U,135
 psdi_data_conversion/testing/constants.py,sha256=BtIafruSobZ9cFY0VW5Bu209eiftnN8b3ObouZBrFQU,521
 psdi_data_conversion/testing/conversion_callbacks.py,sha256=ATR-_BsYCUN8KyOyUjfdWCELzySxLN5jOI0JyrQnmHQ,18858
-psdi_data_conversion/testing/conversion_test_specs.py,sha256=jFik-m-jxNZzZhyfiJVIj7CT4ML8pM4dm7Trs2d0hgg,25602
+psdi_data_conversion/testing/conversion_test_specs.py,sha256=8W97tI6dVbHE9BEW76dsKDlfsm5oTlrlntG--b0h8HU,26106
 psdi_data_conversion/testing/gui.py,sha256=ul7ixYANIzmOG2ZNOZmQO6wsHmGHdiBGAlw-KuoN0j8,19085
 psdi_data_conversion/testing/utils.py,sha256=YrFxjyiIx1seph0j7jCUgAVm6HvXY9QJjx0MvNJRbfw,26134
-psdi_data_conversion-0.0.39.dist-info/METADATA,sha256=QVdwrTA_MdZyiQNOgE2cuVEUh_zA_zs3s9LxQFVY9r4,48116
-psdi_data_conversion-0.0.39.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-psdi_data_conversion-0.0.39.dist-info/entry_points.txt,sha256=xL7XTzaPRr2E67WhOD1M1Q-76hB8ausQlnNiHzuZQPA,123
-psdi_data_conversion-0.0.39.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-psdi_data_conversion-0.0.39.dist-info/RECORD,,
+psdi_data_conversion-0.1.1.dist-info/METADATA,sha256=M5iHWEennMs8JSqTVqyAKco-9a0a5jRWh6u5W192Ag0,48108
+psdi_data_conversion-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+psdi_data_conversion-0.1.1.dist-info/entry_points.txt,sha256=xL7XTzaPRr2E67WhOD1M1Q-76hB8ausQlnNiHzuZQPA,123
+psdi_data_conversion-0.1.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+psdi_data_conversion-0.1.1.dist-info/RECORD,,