psdi-data-conversion 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

psdi_data_conversion/app.py

@@ -10,7 +10,7 @@ from argparse import ArgumentParser
 from psdi_data_conversion import constants as const
 from psdi_data_conversion.gui.env import update_env
 from psdi_data_conversion.gui.setup import get_app, limit_upload_size, start_app
-from psdi_data_conversion.main import print_wrap
+from psdi_data_conversion.utils import print_wrap
 
 app = get_app()
 

psdi_data_conversion/converters/base.py

@@ -20,6 +20,7 @@ from typing import Any
 from psdi_data_conversion import constants as const
 from psdi_data_conversion import log_utility
 from psdi_data_conversion.dist import bin_exists, get_bin_path, get_dist
+from psdi_data_conversion.file_io import get_package_path
 from psdi_data_conversion.security import SAFE_STRING_RE, string_is_safe
 
 try:
@@ -744,7 +745,9 @@ class ScriptFileConverter(FileConverter):
         if self.required_bin is not None:
             env["BIN_PATH"] = get_bin_path(self.required_bin)
 
-        process = subprocess.run(['sh', f'psdi_data_conversion/scripts/{self.script}', *self._get_script_args()],
+        script_abs_path = os.path.join(get_package_path(), "scripts", self.script)
+
+        process = subprocess.run(['sh', script_abs_path, *self._get_script_args()],
                                  env=env, capture_output=True, text=True)
 
         self.out = process.stdout

psdi_data_conversion/converters/openbabel.py

@@ -12,6 +12,7 @@ from openbabel import openbabel
 
 from psdi_data_conversion.converters.base import FileConverter, FileConverterInputException
 from psdi_data_conversion.security import SAFE_STRING_RE, string_is_safe
+from psdi_data_conversion.utils import print_wrap
 
 CONVERTER_OB = 'Open Babel'
 
@@ -83,30 +84,34 @@ class OBFileConverter(FileConverter):
     `run_converter()` through providing a dict to the `data` kwarg. The supported keys and values are:
 
     "from_flags": str
-        String of concatenated one-letter flags for how to read the input file. To list the flags supported for a given
-        input format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look for the
-        "Allowed input flags" section, if one exists, or alternatively call the library function
+        String of concatenated one-letter flags for how to write the output file, e.g. ``"from_flags": "xyz"`` will set
+        flags x, y and z. To list the flags supported for a given output format, call
+        ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look for the "Allowed input flags"
+        section, if one exists, or alternatively call the library function
         ``psdi_data_conversion.database.get_in_format_args("Open Babel", <format>)`` from within Python code.
 
     "to_flags": str
-        String of concatenated one-letter flags for how to write the output file. To list the flags supported for a
-        given output format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look for
-        the "Allowed output flags" section, if one exists, or alternatively call the library function
+        String of concatenated one-letter flags for how to write the output file, e.g. ``"to_flags": "xyz"`` will set
+        flags x, y and z. To list the flags supported for a given output format, call
+        ``psdi-data-convert -l -t <format> -w Open Babel`` at the command-line and look for the "Allowed output flags"
+        section, if one exists, or alternatively call the library function
         ``psdi_data_conversion.database.get_out_format_args("Open Babel", <format>)`` from within Python code.
 
     "from_options": str
         String of space-separated options for how to read the input file. Each option "word" in this string should start
-        with the letter indicating which option is being used, followed by the value for that option. To list the
+        with the letter indicating which option is being used, followed by the value for that option. E.g.
+        ``"from_options": "a1 b2"`` will set the value 1 for option a and the value 2 for option b. To list the
         options supported for a given input format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the
         command-line and look for the "Allowed input options" section, if one exists, or alternatively call the library
         function ``psdi_data_conversion.database.get_in_format_args("Open Babel", <format>)`` from within Python code.
 
     "to_options": str
         String of space-separated options for how to write the output file. Each option "word" in this string should
-        start with the letter indicating which option is being used, followed by the value for that option. To list the
+        start with the letter indicating which option is being used, followed by the value for that option. E.g.
+        ``"to_options": "a1 b2"`` will set the value 1 for option a and the value 2 for option b. To list the
         options supported for a given output format, call ``psdi-data-convert -l -t <format> -w Open Babel`` at the
         command-line and look for the "Allowed output options" section, if one exists, or alternatively call the library
-        function ``psdi_data_conversion.database.get_out_format_args("Open Babel", <format>)`` from within Python code.
+        function ``psdi_data_conversion.database.get_in_format_args("Open Babel", <format>)`` from within Python code.
 
     "coordinates": str
         One of "Gen2D", "Gen3D", or "neither", specifying how positional coordinates should be generated in the output
@@ -159,13 +164,28 @@ class OBFileConverter(FileConverter):
             from_args = self.data.get("from_args", "")
             to_args = self.data.get("to_args", "")
 
+            from psdi_data_conversion.database import (FileConverterDatabaseException, get_in_format_args,
+                                                       get_out_format_args)
+
             # Add option flags and arguments as appropriate
             for char in from_flags:
                 check_string_security(char)
+                # Check that the flag is valid
+                try:
+                    get_in_format_args(self.name, self.from_format_info, char)
+                except FileConverterDatabaseException:
+                    print_wrap(f"WARNING: Input format flag '{char}' not recognised for conversion with {self.name}. "
+                               "If this is valid, the database should be updated to indicate this.", err=True)
                 ob_conversion.AddOption(char, ob_conversion.INOPTIONS)
 
             for char in to_flags:
                 check_string_security(char)
+                # Check that the flag is valid
+                try:
+                    get_out_format_args(self.name, self.from_format_info, char)
+                except FileConverterDatabaseException:
+                    print_wrap(f"WARNING: Output format flag '{char}' not recognised for conversion with {self.name}. "
+                               "If this is valid, the database should be updated to indicate this", err=True)
                 ob_conversion.AddOption(char, ob_conversion.OUTOPTIONS)
 
             self.data["read_flags_args"] = []
@@ -176,37 +196,82 @@ class OBFileConverter(FileConverter):
             if "from_options" in self.data:
                 # From options were provided by the command-line script or library
                 l_from_options = self.data["from_options"].split()
+
                 for opt in l_from_options:
                     option, value = get_option_and_value(opt)
+
+                    # Check that the option is valid
+                    try:
+                        get_in_format_args(self.name, self.from_format_info, option)
+                    except FileConverterDatabaseException:
+                        print_wrap(f"WARNING: Input format option '{option}' not recognised for conversion with "
+                                   f"{self.name}. If this is valid, the database should be updated to indicate "
+                                   "this", err=True)
+
                     ob_conversion.AddOption(option, ob_conversion.INOPTIONS, value)
+
                 self.logger.debug(f"Set Open Babel read flags arguments to: {self.data['from_options']}")
                 # Store the options in the "read_flags_args" entry for the later logging
                 self.data["read_flags_args"] = l_from_options
+
             else:
                 # From options were provided by the command-line script or library
                 for char in from_arg_flags:
+
                     index = from_args.find('£')
                     arg, from_args = from_args[0:index], from_args[index + 1:len(from_args)]
                     check_string_security(char), check_string_security(arg)
+
+                    # Check that the option is valid
+                    try:
+                        get_in_format_args(self.name, self.from_format_info, arg)
+                    except FileConverterDatabaseException:
+                        print_wrap(f"WARNING: Input format option '{arg}' not recognised for conversion with "
+                                   f"{self.name}. If this is valid, the database should be updated to indicate "
+                                   "this.", err=True)
+
                     ob_conversion.AddOption(char, ob_conversion.INOPTIONS, arg)
                     self.data["read_flags_args"].append(char + "  " + arg)
+
                 self.logger.debug(f"Set Open Babel read flags arguments to: {self.data['read_flags_args']}")
 
             if "to_options" in self.data:
                 # From options were provided by the command-line script or library
                 l_to_options = self.data["to_options"].split()
+
                 for opt in l_to_options:
                     option, value = get_option_and_value(opt)
+
+                    # Check that the option is valid
+                    try:
+                        get_in_format_args(self.name, self.to_format_info, option)
+                    except FileConverterDatabaseException:
+                        print_wrap(f"WARNING: Output format option '{option}' not recognised for conversion with "
+                                   f"{self.name}. If this is valid, the database should be updated to indicate "
+                                   "this.", err=True)
+
                     ob_conversion.AddOption(option, ob_conversion.OUTOPTIONS, value)
+
                 self.logger.debug(f"Set Open Babel write flags arguments to: {self.data['to_options']}")
                 # Store the options in the "write_flags_args" entry for the later logging
                 self.data["write_flags_args"] = l_to_options
+
             else:
-                # From options were provided by the command-line script or library
+                # To options were provided by the command-line script or library
                 for char in to_arg_flags:
+
                     index = to_args.find('£')
                     arg, to_args = to_args[0:index], to_args[index + 1:len(to_args)]
                     check_string_security(char), check_string_security(arg)
+
+                    # Check that the option is valid
+                    try:
+                        get_out_format_args(self.name, self.to_format_info, arg)
+                    except FileConverterDatabaseException:
+                        print_wrap(f"WARNING: Output format option '{arg}' not recognised for conversion with "
+                                   f"{self.name}. If this is valid, the database should be updated to indicate "
+                                   "this.", err=True)
+
                     ob_conversion.AddOption(char, ob_conversion.OUTOPTIONS, arg)
                     self.data["write_flags_args"].append(char + "  " + arg)
                 self.logger.debug(f"Set Open Babel write flags arguments to: {self.data['read_flags_args']}")
@@ -239,6 +304,12 @@ class OBFileConverter(FileConverter):
         if "Open Babel Error" in self.err:
             self._abort_from_err()
 
+        # Check for any non-critical errors and print them out
+        l_err_blocks = self.err.split("\n\n")
+        for err_block in l_err_blocks:
+            if err_block.startswith("ERROR:") or err_block.startswith("WARNING:"):
+                print_wrap(err_block, err=True)
+
     def _create_message(self) -> str:
         """Overload method to create a log of options passed to the converter
         """
@@ -248,7 +319,7 @@ class OBFileConverter(FileConverter):
         label_length = 19
 
         for (label, key, multi) in (("Coord. gen.:", COORD_GEN_KEY, False),
-                                    ("Coord. option:", "coord_option", False),
+                                    ("Coord. option:", COORD_GEN_QUAL_KEY, False),
                                     ("Read options:", "from_flags", False),
                                     ("Write options:", "to_flags", False),
                                     ("Read opts + args:", "read_flags_args", True),

psdi_data_conversion/database.py

@@ -24,6 +24,7 @@ from psdi_data_conversion import constants as const
 from psdi_data_conversion.converter import (L_REGISTERED_CONVERTERS, L_SUPPORTED_CONVERTERS,
                                             get_registered_converter_class)
 from psdi_data_conversion.converters.base import FileConverter, FileConverterException
+from psdi_data_conversion.file_io import get_package_path
 from psdi_data_conversion.utils import regularize_name
 
 # Keys for top-level and general items in the database
@@ -1206,10 +1207,7 @@ def get_database_path() -> str:
     str
     """
 
-    # For an interactive shell, __file__ won't be defined for this module, so use the constants module instead
-    reference_file = os.path.realpath(const.__file__)
-
-    qualified_database_filename = os.path.join(os.path.dirname(reference_file), const.DATABASE_FILENAME)
+    qualified_database_filename = os.path.join(get_package_path(), const.DATABASE_FILENAME)
 
     return qualified_database_filename
 
@@ -1432,11 +1430,14 @@ def disambiguate_formats(converter_name: str,
         raise FileConverterDatabaseException(f"Conversion from {in_format} to {out_format} with converter "
                                              f"{converter_name} is not supported", help=True)
     else:
-        msg = (f"Conversion from {in_format} to {out_format} with converter {converter_name} is ambiguous.\n"
-               "Possible matching conversions are:\n")
+        msg = (f"Conversion from {in_format} to {out_format} with converter {converter_name} is ambiguous. Please "
+               "Use the ID or disambiguated name (listed below) of the desired conversion. Possible matching "
+               "conversions are:\n")
         for _, possible_in_format, possible_out_format in l_possible_conversions:
-            msg += (f"{possible_in_format.disambiguated_name} ({possible_in_format.note}) to "
-                    f"{possible_out_format.disambiguated_name} ({possible_out_format.note})\n")
+            msg += (f"    {possible_in_format.id}: {possible_in_format.disambiguated_name} "
+                    f"({possible_in_format.note}) to "
+                    f"{possible_out_format.id}: {possible_out_format.disambiguated_name} "
+                    f"({possible_out_format.note})\n")
         # Trim the final newline from the message
         msg = msg[:-1]
         raise FileConverterDatabaseException(msg, help=True)

psdi_data_conversion/dist.py

@@ -9,7 +9,7 @@ import os
 import shutil
 import sys
 
-import psdi_data_conversion
+from psdi_data_conversion.file_io import get_package_path
 
 # Labels for each platform (which we use for the folder in this project), and the head of the name each platform will
 # have in `sys.platform`
@@ -29,7 +29,7 @@ D_DIST_NAME_HEADS = {LINUX_LABEL: LINUX_NAME_HEAD,
 
 
 # Determine the fully-qualified binary directory when this module is first imported
-BIN_DIR: str = os.path.join(psdi_data_conversion.__path__[0], "bin")
+BIN_DIR: str = os.path.join(get_package_path(), "bin")
 
 
 def get_dist():

psdi_data_conversion/file_io.py

@@ -7,12 +7,30 @@ Functions and classes related to general filesystem input/output
 
 import glob
 import os
+from functools import lru_cache
 from shutil import copyfile, make_archive, unpack_archive
 from tempfile import TemporaryDirectory
 
 from psdi_data_conversion import constants as const
 
 
+@lru_cache(maxsize=1)
+def get_package_path() -> str:
+    """Gets the absolute path to where the `psdi_data_conversion` package is on disk
+
+    Returns
+    -------
+    str
+    """
+
+    # For an interactive shell, __file__ won't be defined for this module, so use the constants module instead
+    reference_file = os.path.realpath(const.__file__)
+
+    package_path = os.path.dirname(reference_file)
+
+    return package_path
+
+
 def is_archive(filename: str) -> bool:
     """Uses a file's extension to check if it's an archive or not
     """

psdi_data_conversion/main.py

@@ -26,20 +26,7 @@ from psdi_data_conversion.database import (FormatInfo, get_conversion_pathway, g
                                            get_out_format_args, get_possible_conversions, 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):
-    """Print a string wrapped to the terminal width
-    """
-    if err:
-        file = sys.stderr
-    else:
-        file = sys.stdout
-    for line in s.split("\n"):
-        print(textwrap.fill(line, width=TERM_WIDTH, **kwargs), file=file)
-    if newline:
-        print("")
+from psdi_data_conversion.utils import print_wrap, regularize_name
 
 
 class ConvertArgs:
@@ -260,29 +247,29 @@ def get_argument_parser():
     parser.add_argument("--delete-input", action="store_true",
                         help="If set, input files will be deleted after conversion, default they will be kept")
     parser.add_argument("--from-flags", type=str, default="",
-                        help="Any command-line flags to be provided to the converter for reading in the input file(s). "
-                             "For information on the flags accepted by a converter and its required format for them, "
-                             "call this script with '-l <converter name>'. If the set of flags includes any spaces, it "
-                             "must be quoted, and if hyphens are used, the first preceding hyphen for each flag must "
-                             "be backslash-escaped, e.g. '--from-flags \"\\-a \\-bc \\--example\"'")
+                        help="String of concatenated one-letter flags for how to read the input file, e.g. "
+                        "``--from-flags xyz`` will set flags x, y, and z. To list the flags supported for a given "
+                        "input format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line "
+                        "and look for the \"Allowed input flags\" section, if one exists.")
     parser.add_argument("--to-flags", type=str, default="",
-                        help="Any command-line flags to be provided to the converter for writing the output file(s). "
-                             "For information on the flags accepted by a converter and its required format for them, "
-                             "call this script with '-l <converter name>'. If the set of flags includes any spaces, it "
-                             "must be quoted, and if hyphens are used, the first preceding hyphen for each flag must "
-                             "be backslash-escaped, e.g. '--to-flags \"\\-a \\-bc \\--example\"'")
+                        help="String of concatenated one-letter flags for how to write the output file, e.g. "
+                        "``--from-flags xyz`` will set flags x, y, and z. To list the flags supported for a given "
+                        "output format, call ``psdi-data-convert -l -t <format> -w Open Babel`` at the command-line "
+                        "and look for the \"Allowed output flags\" section, if one exists.")
     parser.add_argument("--from-options", type=str, default="",
-                        help="Any command-line options to be provided to the converter for reading in the input "
-                             "file(s). For information on the options accepted by a converter and its required format "
-                             "for them, call this script with '-l <converter name>'. If the set of options includes "
-                             "any spaces, it must be quoted, and the first preceding hyphen for each option must be "
-                             "backslash-escaped, e.g. '--from-options \"\\-x xval --opt optval\"'")
+                        help="String of space-separated options for how to read the input file. Each option \"word\" "
+                        "in this string should start with the letter indicating which option is being used, followed "
+                        "by the value for that option. E.g. ``--from_options a1 b2`` will set the value 1 for "
+                        "option a and the value 2 for option b. To list the options supported for a given input "
+                        "format, call ``psdi-data-convert -l -f <format> -w Open Babel`` at the command-line and look "
+                        "for the \"Allowed input options\" section, if one exists.")
     parser.add_argument("--to-options", type=str, default="",
-                        help="Any command-line options to be provided to the converter for writing the output "
-                             "file(s). For information on the options accepted by a converter and its required format "
-                             "for them, call this script with '-l <converter name>'. If the set of options includes "
-                             "any spaces, it must be quoted, and the first preceding hyphen for each option must be "
-                             "backslash-escaped, e.g. '--to-options \"\\-x xval --opt optval\"'")
+                        help="String of space-separated options for how to write the output file. Each option \"word\" "
+                        "in this string should start with the letter indicating which option is being used, followed "
+                        "by the value for that option. E.g. ``--to_options a1 b2`` will set the value 1 for "
+                        "option a and the value 2 for option b. To list the options supported for a given output "
+                        "format, call ``psdi-data-convert -l -t <format> -w Open Babel`` at the command-line and look "
+                        "for the \"Allowed input options\" section, if one exists.")
     parser.add_argument("-s", "--strict", action="store_true",
                         help="If set, will fail if one of the input files has the wrong extension (including those "
                         "contained in archives, but not the archive files themselves). Otherwise, will only print a "
@@ -399,13 +386,17 @@ def detail_converter_use(args: ConvertArgs):
 
         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) + "   -----  ------")
+        print(" "*(max_format_length+4) + "    INPUT    OUTPUT    DESCRIPTION")
+        print(" "*(max_format_length+4) + "    -----    ------    -----------")
         for file_format in l_all_formats:
             in_yes_or_no = "yes" if file_format in l_input_formats else "no"
             out_yes_or_no = "yes" if file_format in l_output_formats else "no"
-            print(f"    {file_format.disambiguated_name:>{max_format_length}}{in_yes_or_no:>8}{out_yes_or_no:>8}")
-        print("")
+            print(f"    {file_format.disambiguated_name:>{max_format_length}}    {in_yes_or_no:<9}{out_yes_or_no:<10}"
+                  f"{file_format.note}")
+        print_wrap("\nFor more information on a format, including its ID (which can be used to specify it uniquely in "
+                   "case of ambiguity, and is resilient to database changes affecting the disambiguated names listed "
+                   "above), call:\n"
+                   f"{CL_SCRIPT_NAME} -l -f <format>", newline=True)
 
     if converter_class.allowed_flags is None:
         print_wrap("Information has not been provided about general flags accepted by this converter.", newline=True)

psdi_data_conversion/testing/constants.py

@@ -9,7 +9,7 @@ import os
 # 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
 
-TEST_DATA_LOC_IN_PROJECT = "./test_data"
+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/utils.py

@@ -11,6 +11,7 @@ import shlex
 import sys
 from collections.abc import Callable, Iterable
 from dataclasses import dataclass, field
+from functools import lru_cache
 from math import isclose
 from tempfile import TemporaryDirectory
 from typing import Any
@@ -19,32 +20,43 @@ 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.database import get_format_info
 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.file_io import get_package_path, 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_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"""
+@lru_cache(maxsize=1)
+def get_project_path() -> str:
+    """Gets the absolute path to where the project is on disk, using the package path to find it and checking that it
+    contains the expected files
+
+    Returns
+    -------
+    str
+    """
 
-    old_cwd = os.getcwd()
+    project_path = os.path.abspath(os.path.join(get_package_path(), ".."))
 
-    try:
-        os.chdir(os.path.join(psdi_data_conversion.__path__[0], ".."))
-        realpath = os.path.realpath(filename)
+    # Check that the project path contains the expected test_data folder
+    if not os.path.isdir(os.path.join(project_path, TEST_DATA_LOC_IN_PROJECT)):
+        raise FileNotFoundError(f"Project path was expected to be '{project_path}', but this does not contain the "
+                                f"expected directory '{TEST_DATA_LOC_IN_PROJECT}'")
 
-    finally:
-        # Change back to the previous directory
-        os.chdir(old_cwd)
+    return project_path
+
+
+def get_path_in_project(filename):
+    """Get the realpath to a file contained within the project, given its project-relative path"""
+
+    abs_path = os.path.abspath(os.path.join(get_project_path(), filename))
 
-    return realpath
+    return abs_path
 
 
 def get_test_data_loc():
@@ -567,7 +579,7 @@ def check_file_match(filename: str, ex_filename: str) -> str:
 
     # Read in both files
     text = open(filename, "r").read()
-    ex_text = open(ex_filename, "r").read()
+    ex_text = open(get_path_in_project(ex_filename), "r").read()
 
     # We want to check they're the same without worrying about whitespace (which doesn't matter for this format),
     # so we accomplish this by using the string's `split` method, which splits on whitespace by default

psdi_data_conversion/utils.py

@@ -5,6 +5,25 @@ Miscellaneous utility functions used by this project
 """
 
 
+import sys
+import textwrap
+
+from psdi_data_conversion.constants import TERM_WIDTH
+
+
+def print_wrap(s: str, newline=False, err=False, **kwargs):
+    """Print a string wrapped to the terminal width
+    """
+    if err:
+        file = sys.stderr
+    else:
+        file = sys.stdout
+    for line in s.split("\n"):
+        print(textwrap.fill(line, width=TERM_WIDTH, **kwargs), file=file)
+    if newline:
+        print("")
+
+
 def regularize_name(name: str):
     """Regularizes a name for comparisons, making it lowercase and stripping spaces
 

{psdi_data_conversion-0.2.1.dist-info → psdi_data_conversion-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: psdi_data_conversion
-Version: 0.2.1
+Version: 0.2.3
 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/
@@ -293,6 +293,7 @@ This is the repository for the PSDI PF2 Chemistry File Format Conversion project
     - [Input file is malformatted or corrupt](#input-file-is-malformatted-or-corrupt)
     - [Input file's format is misidentified](#input-files-format-is-misidentified)
     - [Other known issues](#other-known-issues)
+- [Feedback](#feedback)
 - [Licensing](#licensing)
 - [Contributors](#contributors)
 - [Funding](#funding)
@@ -484,12 +485,17 @@ options] [-s/--strict] [--nc/--no-check] [-q/--quiet] [-g/--log-file <log file n
 
 Call `psdi-data-convert -h` for details on each of these options.
 
-Note that some requested conversions may involve ambiguous formats which share the same extension. In this case, the application will print a warning and list possible matching formats, with a disambiguating name that can be used to specify which one. For instance, the `c2x` converter can convert into two variants of the `pdb` format, and if you ask it to convert to `pdb` without specifying which one, you'll see:
+Note that some requested conversions may involve ambiguous formats which share the same extension. In this case, the application will print a warning and list possible matching formats, with IDs and disambiguating names that can be used to specify which one. For instance, the `c2x` converter can convert into two variants of the `pdb` format, and if you ask it to convert to `pdb` without specifying which one, you'll see:
 
 ```
-ERROR: Extension 'pdb' is ambiguous and must be defined by ID. Possible formats and their IDs are:
+WARNING: Format 'pdb' is ambiguous and could refer to multiple formats. It may be necessary to explicitly specify which
+you want to use when calling this script, e.g. with '-f pdb-0' - see the disambiguated names in the list below:
+
 9: pdb-0 (Protein Data Bank)
+...
+
 259: pdb-1 (Protein Data Bank with atoms numbered)
+...
 ```
 
 This provides the IDs ("9" and "259") and disambiguating names ("pdb-0" and "pdb-1") for the matching formats. Either can be used in the call to the converter, e.g.:
@@ -745,38 +751,69 @@ To remedy this, try explicitly specifying the format, rather than letting the ap
 `<format>` here can be the standard extension of the format (in the case of unambiguous extensions), its ID, or its disambiguated name. To give an example which explains what each of these are, let's say you have an MDL MOL file you wish to convert to XYZ, so you get information about it and possible converters with `psdi-data-convert -l -f mol -t xyz`:
 
 ```base
-$ psdi-data-convert -l -f mol
+$ psdi-data-convert -l -f mol -t xyz
 WARNING: Format 'mol' is ambiguous and could refer to multiple formats. It may be necessary to explicitly specify which
 you want to use when calling this script, e.g. with '-f mol-0' - see the disambiguated names in the list below:
 
 18: mol-0 (MDL MOL)
+- Atomic composition is supported
+- Atomic connections are supported
+- 2D atomic coordinates are supported
+- 3D atomic coordinates are supported
+
 216: mol-1 (MOLDY)
+- Atomic composition is unknown whether or not to be supported
+- Atomic connections are unknown whether or not to be supported
+- 2D atomic coordinates are unknown whether or not to be supported
+- 3D atomic coordinates are unknown whether or not to be supported
+
+WARNING: Format 'xyz' is ambiguous and could refer to multiple formats. It may be necessary to explicitly specify which
+you want to use when calling this script, e.g. with '-f xyz-0' - see the disambiguated names in the list below:
 
-20: xyz (XYZ cartesian coordinates)
+20: xyz-0 (XYZ cartesian coordinates)
+- Atomic composition is supported
+- Atomic connections are not supported
+- 2D atomic coordinates are supported
+- 3D atomic coordinates are supported
 
-The following registered converters can convert from mol-0 to xyz:
+284: xyz-1 (Extended XYZ (adds lattice vectors))
+- Atomic composition is unknown whether or not to be supported
+- Atomic connections are unknown whether or not to be supported
+- 2D atomic coordinates are unknown whether or not to be supported
+- 3D atomic coordinates are unknown whether or not to be supported
+
+The following registered converters can convert from mol-0 to xyz-0:
 
     Open Babel
     c2x
 
 For details on input/output flags and options allowed by a converter for this conversion, call:
-psdi-data-convert -l <converter name> -f mol-0 -t xyz
+psdi-data-convert -l <converter name> -f mol-0 -t xyz-0
+
+The following registered converters can convert from mol-0 to xyz-1:
 
-The following registered converters can convert from mol-1 to xyz:
+    c2x
+
+For details on input/output flags and options allowed by a converter for this conversion, call:
+psdi-data-convert -l <converter name> -f mol-0 -t xyz-1
+
+The following registered converters can convert from mol-1 to xyz-0:
 
     Atomsk
 
 For details on input/output flags and options allowed by a converter for this conversion, call:
-psdi-data-convert -l <converter name> -f mol-1 -t xyz
+psdi-data-convert -l <converter name> -f mol-1 -t xyz-0
+
+No converters are available which can perform a conversion from mol-1 to xyz-1
 ```
 
-This output indicates that the application is aware of two formats which share the `mol` extension: MDL MOL and MOLDY. It lists the ID, disambiguated name, and description of each: ID `18` and disambiguated name `mol-0` for MDL MOL, and ID `216` and disambiguated name `mol-1` for MOLDY. The XYZ format, on the other hand, is unambiguous, and only lists the standard extension for it as its disambiguated name (although `xyz-0` will be accepted without error as well).
+This output indicates that the application is aware of two formats which share the `mol` extension: MDL MOL and MOLDY. It lists the ID, disambiguated name, and description of each: ID `18` and disambiguated name `mol-0` for MDL MOL, and ID `216` and disambiguated name `mol-1` for MOLDY. The XYZ format similarly has two variants which can be converted to.
 
 The program then lists converters which can handle the requested conversion, revealing a potential pitfall: The Open Babel and c2x converters can convert from MDL MOL to XYZ, which the Atomsk converter can convert from MOLDY to XYZ. If you don't specify which format you're converting from, the script might assume you meant to use the other one, if that's the only one compatible with the converter you've requested (or with the default converter, Open Babel, if you didn't explicitly request one). So to be careful here, it's best to specify this input format unambiguously.
 
 Since in this example you have an MDL MOL file, you would use `-f 18` or `-f mol-0` to explicitly specify it in the command-line, or similarly provide one of these to the `from_format` argument of `run_converter` within Python. The application will then properly handle it, including alerting you if you request a conversion that isn't supported by your requested converter (e.g. if you request a conversion of this MDL MOL file to XYZ with Atomsk).
 
-Important note: The disambiguated name is generated dynamically and isn't stored in the database, and in rare cases may change for some formats in future versions of this application which expand support to more formats and conversions. For uses which require forward-compatibility with future versions of this application, the ID should be used instead.
+Important note: The disambiguated name is generated dynamically and isn't stored in the database, and in rare cases may change for some formats in future versions of this application which expand support to more formats and conversions. For uses which require forward-compatibility with future versions of this application, the ID should be used instead. You can obtain the ID for any format via the command: `psdi-data-convert -l -f <format-name>`.
 
 #### Other known issues
 
@@ -784,6 +821,10 @@ Through testing, we've identified some other conversion issues, which we list he
 
 - Open Babel will indefinitely hang when attempting to convert large files (more than ~1 MB) of certain types (such as `mmcif`). This is an issue with the converter itself and not our application, which we hope will be fixed in a future version. If this occurs, the job will have to be forcibly terminated. CTRL+C will fail to terminate it, but it can be stopped with CTRL+Z, then terminated with `kill %N`, where N is the number listed beside the job when it is stopped (usually 1). The conversion should then be attempted with another supported converter.
 
+## Feedback
+
+To report a missing format or conversion, please use [the form on the public web service](https://data-conversion.psdi.ac.uk/report.htm). Other feedback can be submitted on [the feedback page](https://data-conversion.psdi.ac.uk/static/content/feedback.htm).
+
 ## Licensing
 
 This project is provided under the Apache License version 2.0, the terms of which can be found in the file `LICENSE`.

{psdi_data_conversion-0.2.1.dist-info → psdi_data_conversion-0.2.3.dist-info}/RECORD

@@ -1,14 +1,14 @@
 psdi_data_conversion/__init__.py,sha256=urMsTqsTHTch1q4rMT9dgGnrvdPFMP9B8r-6Kr8H5sE,404
-psdi_data_conversion/app.py,sha256=VmZlIAZ_J9W6p_WUcTA_2UNmZxssmq1aT72I2d1ObDc,3606
+psdi_data_conversion/app.py,sha256=u26a6taxmS3Yn9o78hL1avpO-50BnbcMnJAuVn5XlEc,3607
 psdi_data_conversion/constants.py,sha256=eXE43_9YFahoehiUV7FtqN9MKb-UpSfY2win9ic9W8I,7348
 psdi_data_conversion/converter.py,sha256=OlwGKxI8nj76wrlVzP5S7fpXb6L-Ql8-mYLYGhW81Fk,27816
-psdi_data_conversion/database.py,sha256=7Xm5e8Wi3b2wGUh2soBZ4DdJ0PhVSXAvv1dVCXDhNQg,65685
-psdi_data_conversion/dist.py,sha256=LOcKEP7H7JA9teX1m-5awuBi69gmdhtUit7yxtCTOZ8,2293
-psdi_data_conversion/file_io.py,sha256=LvdPmnYL_7Xlcr-7LJjUbbky4gKiqTTvPRzdbtvQaJo,8794
+psdi_data_conversion/database.py,sha256=uE2s9RelTmcsr8u42nKdTJfmobysO2PY-B_7rl7TecQ,65766
+psdi_data_conversion/dist.py,sha256=Db7mbLLANfugaptrcWCoVddwHT2rdP4X4HuP6uxr9AI,2309
+psdi_data_conversion/file_io.py,sha256=SE7cXVedm5ZLdxDQ7W7L2R9LXTqJz2Tak9-YTvc7_js,9250
 psdi_data_conversion/log_utility.py,sha256=CHAq-JvBnTKaE0SHK5hM5j2dTbfSli4iUc3hsf6dBhc,8789
-psdi_data_conversion/main.py,sha256=LWiYiELF_LY1GghQLt37eZS3ZNojmwHWuSnAhe3qbDI,44768
+psdi_data_conversion/main.py,sha256=_HmlDicG7TD7-taLNPazZS4rflXUU7ijHv3Tzx5kyLM,44770
 psdi_data_conversion/security.py,sha256=wjdrMre29TpkF2NqrsXJ5sschSAnDzqLYTLUcNR21Qw,902
-psdi_data_conversion/utils.py,sha256=iTjNfrD4n_hU9h20ldYrX2Bmp5KhCBIeMSUMLtPZ_8k,402
+psdi_data_conversion/utils.py,sha256=1DaTxoaUkoiImBYyXIiPToV2ae2eZEDPxbNWUvEqwDg,821
 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
@@ -17,9 +17,9 @@ psdi_data_conversion/bin/mac/atomsk,sha256=pqExRdkR8NSqSasHZjE74R_CiM6Dkr_yvfyak
 psdi_data_conversion/bin/mac/c2x,sha256=dI-bBoQ6uqc6KMYKJaq0x7ejJgOf_wysTxQA5BrF8AY,2581960
 psdi_data_conversion/converters/__init__.py,sha256=15Ldt06eyZ0bgNPB4qg419U0Zcjt6TUCTzjCBo8EIzM,210
 psdi_data_conversion/converters/atomsk.py,sha256=_V33me1e4HW0-YXvdE-z6PdwtSK2gYV6QZf5d8aPqH4,1523
-psdi_data_conversion/converters/base.py,sha256=0hK9IeC306zvQ1qAWb19eI_m_e6CA8TfuEoWgypimeo,36403
+psdi_data_conversion/converters/base.py,sha256=yGlwQmYcLSKP9DH2reTBGvJ-HhfxjO_dYo6qVX501Zw,36515
 psdi_data_conversion/converters/c2x.py,sha256=jDA84H8Jpz--ajTWNWX6K6oMfOMMbMxkA31-VnGi0gU,2019
-psdi_data_conversion/converters/openbabel.py,sha256=OYppOMfnvxmVgRY5vUkcVokWn-bQSSeG8MOFqN1MCIY,13224
+psdi_data_conversion/converters/openbabel.py,sha256=L1R9gc1oU2w_OUqU5Fduz_xT_l8ZPRVG915jOYnKCdE,16956
 psdi_data_conversion/gui/__init__.py,sha256=Q52GAaJWfNWGDOAEM_fIfAoivLIgM3krhVTiHFTRixM,125
 psdi_data_conversion/gui/accessibility.py,sha256=XQyAAJZQdIyRftfidhhVgsZXVtA9b9qZhwwFm899kbE,1302
 psdi_data_conversion/gui/env.py,sha256=nVuKzuE6z9ItH09ZRkooGRUTVZSHtPzSR9XrZVDHC-0,9235
@@ -82,13 +82,13 @@ psdi_data_conversion/templates/documentation.htm,sha256=BeEPgklJOB9tA6jna0Qp4lwR
 psdi_data_conversion/templates/index.htm,sha256=zY9zihO6adJwLU8bB-iaz0AAsRvg24CNx2gVXJFqNLw,7858
 psdi_data_conversion/templates/report.htm,sha256=bru_5EtKqHtKnQ3JB9HpTdK047zCwd5akTLQr2pGd5c,5612
 psdi_data_conversion/testing/__init__.py,sha256=Xku7drtLTYLLPsd403eC0LIEa_iohVifyeyAITy2w7U,135
-psdi_data_conversion/testing/constants.py,sha256=BtIafruSobZ9cFY0VW5Bu209eiftnN8b3ObouZBrFQU,521
+psdi_data_conversion/testing/constants.py,sha256=uYUp3FIwoXG_mDFgitpv0bD5M3xK5ThVm9fUHooons0,519
 psdi_data_conversion/testing/conversion_callbacks.py,sha256=ATR-_BsYCUN8KyOyUjfdWCELzySxLN5jOI0JyrQnmHQ,18858
 psdi_data_conversion/testing/conversion_test_specs.py,sha256=PFzTZYonQ0PsZBKjcn0Hp-UPbwphT3zRH5v-VdNImmQ,27585
 psdi_data_conversion/testing/gui.py,sha256=ul7ixYANIzmOG2ZNOZmQO6wsHmGHdiBGAlw-KuoN0j8,19085
-psdi_data_conversion/testing/utils.py,sha256=A2CDiGr4Gah1eRvGwFmHt1m0F7RdXOxzCuTyYhcAIR4,26122
-psdi_data_conversion-0.2.1.dist-info/METADATA,sha256=jv8iuV3VSQz_4NzFcG5bvTSzO5Ib7WysLqEWFYQ04NU,48538
-psdi_data_conversion-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-psdi_data_conversion-0.2.1.dist-info/entry_points.txt,sha256=xL7XTzaPRr2E67WhOD1M1Q-76hB8ausQlnNiHzuZQPA,123
-psdi_data_conversion-0.2.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-psdi_data_conversion-0.2.1.dist-info/RECORD,,
+psdi_data_conversion/testing/utils.py,sha256=uhJQUceaNmpQd3SioFLZVMExMVzO3Ds8V9DD2hqP-mQ,26700
+psdi_data_conversion-0.2.3.dist-info/METADATA,sha256=zCwJY99aohLJ_Cekj0rPP0mz2ieo8WI9qBu7ZuSM-Z8,50396
+psdi_data_conversion-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+psdi_data_conversion-0.2.3.dist-info/entry_points.txt,sha256=xL7XTzaPRr2E67WhOD1M1Q-76hB8ausQlnNiHzuZQPA,123
+psdi_data_conversion-0.2.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+psdi_data_conversion-0.2.3.dist-info/RECORD,,